Biorąc pod uwagę dwa słowa, łyżkuj je, zmieniając ich początkowe gromady spółgłoskowe. Wygrywa najmniej bajtów.

plaster man -> master plan
blushing crow -> crushing blow
litigating more -> mitigating lore
strong wrangler -> wrong strangler
def ghi -> ghef di
few years -> yew fears

Spółgłoski pojawiające się przed pierwszą samogłoską ( aeiou) są zamieniane.

Dane wejściowe: dwa małe litery, które zaczynają się od różnych spółgłosek i każda zawiera samogłoskę aeiou.

Wyjście: dwa spłaszczone łańcuchy w odpowiedniej kolejności.

W przypadku danych wejściowych i / lub wyjściowych dwa ciągi mogą również znajdować się na liście lub tym podobnych, lub jako pojedynczy ciąg z separatorem.

    var QUESTION_ID=69385,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/69385/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

    body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

**Leaderboard:**

To prawie dupe tego starego pytania , ale mam nadzieję napisać specyfikację, która będzie jaśniejsza i bardziej stabilna, aby stary mógł zostać zamknięty jako duplikat .

Vim, 18 klawiszy

/[aeiou]<CR>dbwvnhp0P

Kluczową sztuczką jest to, że wklejenie czegoś w trybie wizualnym faktycznie powoduje umieszczenie starej zawartości zaznaczenia wizualnego w buforze wklejania.

pieprzenie mózgu, 238 207 bajtów

,[[<+<+>>-]++++[<-------->-]-[<<-->>-----]<<+++++[----[----[------[------>>]]]]>[>>]>,]<<++++++++[<[++++<<]<++++<[++++<<]>>[>>]>>[>>]<-]<[<<]-[<+>---]>[>.>]<[<<]<<[<<]>[>>]>[.>>]<.<[<<]>[>.>]>[>>]>[>>]>[.>>]

Wymaga ,zwrócenia 0 na EOF, 8-bitowym zawijaniu komórek i możliwości przejścia w lewo z komórki 0. Z mojego doświadczenia są to najczęściej używane ustawienia domyślne.

Jestem z tego całkiem zadowolony. Moja pierwsza próba miała 314 bajtów i jest to z pewnością poprawa. :)

Działa poprzez przechowywanie każdego bajtu z danych wejściowych w dwóch komórkach; jeden z rzeczywistą wartością bajtu, a drugi z wyjściem następującego kodu, gdy podano (wartość bajtu - 97):

[
    ----
    [
        ----
        [
            ------
            [
                ------>>
            ]
        ]
    ]
]

Jeśli znak jest spółgłoską, wychodzi z tego z niezerową wartością. Jeśli jest to samogłoska, to staje się 0. Stamtąd wystarczy po prostu ustalić, gdzie zaczyna się drugie słowo i wydrukować wszystko w kolejności.

238 bajtowa wersja tego programu znalazła znak spacji po zebraniu wszystkich danych wejściowych. To był ból głowy, ponieważ wiązało się to z utworzeniem komórki, która zawierała 0 dokładnie tam, gdzie próbowałem na nią zapętlić. Sposób, w jaki rozwiązałem, spowodował odjęcie 30 od każdego znaku w pierwszym słowie i 32 od każdego znaku po nim. Dość duża część kodu została poświęcona obsłudze tych bzdur.

Teraz 32 odejmuje się od każdego znaku w pętli wejściowej, który jest krótszy i ma podobny efekt uboczny, z którym łatwiej sobie poradzić. Jako bonus, zrobienie tego w ten sposób pozwoliło mi stworzyć moją własną postać spacji w krótszy sposób: Zamiast odejmować 139 od 171 (171 dostajesz, gdy biegniesz spacją przez detektor samogłoski powyżej), pętla, która dodaje 32 do każdej postaci dokłada wszelkich starań, aby dodać 32 do komórki 171. To kosztuje cztery bajty, ale oznacza to, że mogę odjąć 171 później (zamiast odjąć 139), aby zaoszczędzić 3 bajty netto.

Z komentarzami:

For every input character
,[

  Make a copy
  [<+<+>>-]

  Subtract 32 from one
  ++++[<-------->-]

  Subtract 97 from the other
  -[<<-->>-----]<<+++++

  If nonzero:
  [

    Subtract 4
    ----

    If nonzero:
    [

      Subtract 4
      ----

      If nonzero:
      [

        Subtract 6
        ------

        If nonzero:
        [

          Subtract 6
          ------>>

        ]

      ]

    ]

  ]

>[>>]>,]

Add 32 to every character and the 171 that the space left behind
<<++++++++[<[++++<<]<++++<[++++<<]>>[>>]>>[>>]<-]

Go to the space
<[<<]

Subtract 171 from (32 plus 171)
-[<+>---]

~~~~~~~~~~~~~~~

Ready to print!

~~~~~~~~~~~~~~~

Print letters from the second word until the value to the left is zero
>[>.>]

Go to the beginning of the first word
<[<<]<<[<<]

Look at cells to the left of letters in the first word until reaching a zero
>[>>]

Print the rest of the letters in the first word
>[.>>]

Print a space
<.

Go to the beginning of the first word
<[<<]

Print letters from the first word until the value to the left is zero
>[>.>]

Go to the beginning of the second word
>[>>]

Look at cells to the left of letters in the second word until reaching a zero
>[>>]

Print the rest of the letters in the second word
>[.>>]

vim, 23

/[aeiou]<cr>"xd0wndb0Pw"xP

Zastanawiam się, czy vim rzeczywiście jest konkurencyjny w tym wyzwaniu. Prawdopodobnie nie z językami golfowymi, ale być może z Ruby / Python / Perl / etc.

/[aeiou]<cr>  Find the first vowel
"xd0          "Delete" (cut), to register "x, everything from here to BOL
w             Go to next word
n             Find next vowel
db            "Delete back" - delete from here to the beginning of the word
0             Go to BOL
P             Paste what we just "deleted" (cut) behind the cursor
w             Next word
"xP           Paste backwards from register "x

Python, 68 63 60 bajtów

import re
lambda s:re.sub('([^aeiou]+|.+ )'*3,r'\3\2\1',s,1)

Wypróbuj online na Ideone .

Jak to działa

Ciąg wzorca jest powtarzany trzy razy ( *3), co powoduje powstanie wzorca

([^aeiou]+|.+ )([^aeiou]+|.+ )([^aeiou]+|.+ )

Wszystkie instancje będą pasować do niepustego ciągu nieposiadającego samogłosek lub niepustego ciągu, po którym następuje pojedynczy znak spacji.

Pierwsze wystąpienie będzie pasować do spółgłosek na początku pierwszego słowa. Ponieważ +jest chciwy, będzie próbował dopasować jak najwięcej, tj. Wszystkie do pierwszej samogłoski.

Z tego powodu druga instancja rozpocznie się od samogłoski, więc będzie pasować do reszty pierwszego słowa, aż do spacji oddzielającej słowa.

Podobnie jak w pierwszym przypadku, trzeci dopasuje wszystkie spółgłoski na początku drugiego słowa, co spowoduje pomyślne dopasowanie dla całego wzorca.

Nieprzetworzony ciąg znaków \3\2\1( runiemożliwia Pythonowi zamianę \3itp. Na znaki kontrolne) odwraca kolejność dopasowywania nawiasowych wzorców, tzn. Zastępuje je spółgłosek na początku drugiego słowa, a następnie wszystkich znaków z pierwszej samogłoski pierwsze słowo do spacji, a na końcu spółgłosek na początku pierwszego słowa.

Ostatni argument argumentu sub( 1) powoduje, że zwraca on natychmiast po pierwszym udanym zastąpieniu, aby uniknąć bezsensownych zamian w pozostałej części drugiego słowa. Jest to wymagane, ponieważ wzór może pasować do dowolnego ciągu trzech lub więcej kolejnych spółgłosek.

JavaScript (ES6), 54 bajty

s=>s.replace(r=/\b[^aeiou ]+/g,(_,i)=>s.match(r)[+!i])

Wyjaśnienie

s=>
  s.replace(
    r=/\b[^aeiou ]+/g,     // r = regex to match consonants
    (_,i)=>s.match(r)[+!i] // replace consonants with the consonants from the other word
  )

Test

var solution = s=>s.replace(r=/\b[^aeiou ]+/g,(_,i)=>s.match(r)[+!i])

<input type="text" id="input" value="plaster man" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Python 3, 108 101 99 bajtów

(Bez użycia wyrażenia regularnego)

Ta funkcja oczekuje danych wejściowych za pomocą 2 argumentów, np f('blushing','crow'). Zwraca nowe słowa w krotce.

S=lambda s,p="":s[0]in"aeiou"and(p,s)or S(s[1:],p+s[0])
def f(x,y):a,b=S(x);c,d=S(y);return c+b,a+d

Istnieje wiele rozwiązań wyrażeń regularnych, więc chciałem napisać coś, co nie korzystało z biblioteki re Pythona.

Jak to działa

Jedyną skomplikowaną częścią jest wyrażenie lambda S(skrót oznacza „ S plit przed pierwszą samogłoską”). Rekurencyjnie „iteruje” po danym słowie, przenosząc po jednym znaku od początku s(który zaczyna się od całego słowa) do końca p(który zaczyna się pusty). Przy pierwszej napotkanej samogłosce zwraca (p,s), tj. (Przedrostek, przyrostek). Zauważ, że jest to niewłaściwa kolejność w porównaniu do parametrów!

Pomyślałem, że bardziej sensowne jest, aby zwrócone zamówienie było prefiksem, a następnie sufiksem (ponieważ generalnie prefiks występuje przed sufiksem). Ta kolejność może a,b=S(x)nieco ułatwić odczytanie kodu.

Ale nie miałem wyboru kolejności parametrów lambda, więc nie mogłem pwcześniej zdefiniować s. Pierwszy parametr s, miał wziąć całe słowo, bo pmiał wartość domyślną, a domyślne parametry przejść ostatni. Dzięki temu nie musiałem wywoływać funkcji Sdwa razy z pustym łańcuchem i można było zapisać kilka bajtów. Być może jednak była to po prostu zła decyzja o zwróceniu prefiksu / sufiksu w odwrotnej kolejności, ponieważ zastosowano go w wyrażeniu lambda.

Jeśli chodzi o wybór wyrażenia lambda def S(s,p=""):returnzamiast funkcji, potrzeba więcej bajtów niż powiedzieć S=lambda s,p="":. Mogę dokonać tego wyboru, ponieważ Python ma ocenę zwarć i operator trójskładnikowy. Nie potrafię jednak odpowiednio wyjaśnić, w jaki sposób zastosowałem zwarcia; trudno jest o tym myśleć.

To moja pierwsza odpowiedź. Mam nadzieję, że zrobiłem to poprawnie i że warto opublikować rozwiązanie, które nie może wygrać.

Edycja: Komentatorzy z podziękowaniami: nieco, dwukrotnie zmniejszono liczbę bajtów i usunięto niepotrzebne informacje. Próbowano poprawić pisanie. Mam nadzieję, że nie popełniłem błędów.

C # 6, 115 bajtów

string S(string a)=>System.Text.RegularExpressions.Regex.Replace(a,"([^aeiou]*)(.*) ([^aeiou]*)(.*)","$3$2 $1$4");

To tylko ból, że przestrzeń nazw dla wyrażenia regularnego jest tak długa.

CJam, 27 24 22 bajtów

2{l_{"aeiou"&}#/(N\}*o

I / O to jedno słowo w wierszu. Wypróbuj online!

Jak to działa

2{                 }*   Do the following twice:
  l                       Read a line from STDIN.
   _                      Push a copy.
    {"aeiou"&}#           Find the index of the first character that has a non-
                          empty intersection with the string "aeiou".
               /          Split the string into chunks of that size.
                (         Shift out the first chunk, i.e., all leading consonants.
                 N\       Swap the shifted out chunk with a linefeed.
                     o  Print the topmost stack item.

Perl, 33 bajty

s/([^aeiou]+)(.+ )((?1))/\3\2\1/

Powyższy kod ma długość 32 bajtów i wymaga -pprzełącznika ( +1 bajt ).

Podstawienie jest bardzo podobne do odpowiedzi Retina @ DigitalTrauma , ale ta odpowiedź korzysta z rekurencyjnych subpatentów PCRE .

Wypróbuj online na Ideone .

Retina , 34

([^aeiou]+)(.+ )([^aeiou]+)
$3$2$1

Wypróbuj online.

JavaScript ES6, 93 58 52 bajtów

Zaoszczędź 6 bajtów dzięki ETHProductions!

x=>x.replace(/([^aeiou]+)(.+ )([^aeiou]+)/,"$3$2$1")

Sprawdź to! (Tylko ES6)

F=x=>x.replace(/([^aeiou]+)(.+ )([^aeiou]+)/,"$3$2$1");

console.log=_=>u.innerHTML+=_;

console.log(`plaster man -> master plan
blushing crow -> crushing blow
litigating more -> mitigating lore
strong wrangler -> wrong strangler
def ghi -> ghef di`.split`\n`.map(e=>(e=e.split` -> `,`${e[0]} => ${e[1]} ||> `+(F(e[0])==e[1]))).join`<br>`);

html { font-family: Consolas, monospace; }

<div id=u></div>

C, 255 201 199 bajtów

Nie widzę tu wielu odpowiedzi w języku C, więc ciesz się; Również mile widziane granie w golfa, sugestie i krytyka.

#define S(w,p)p=strpbrk(w,"aeiou")-w
#define c ;strcpy(r
#define l c+strlen(v[1])+b+1
main(int q,char**v){char r[64],S(v[1],a),S(v[2],b)c,v[2])c+b,v[1]+a);strcat(r," ")l-a,v[1])l,v[2]+b);puts(r);}

Jeśli main () nie jest wymagany, możemy zapisać 24 bajty, dochodząc do 179 bajtów

#define S(w,p)p=strpbrk(w,"aeiou")-w
#define c ;strcpy(r
#define l c+strlen(x)+b+1
s(char*x,char*y){char r[64],S(x,a),S(y,b)c,y)c+b, x+a);strcat(r," ")l-a,x)l,y+b);puts(r);}

Nie golfowany:

void spoonerise(char* w1, char* w2)
{
    char rt[64];

    int p1 = strpbrk(w1, "aeiou")-w1;
    int p2 = strpbrk(w2, "aeiou")-w2;

    strcpy(rt, w2);
    strcpy(rt+p2, w1+p1);

    strcat(rt, " ");

    strcpy(rt+strlen(w1)+p2+1-p1, w1);
    strcpy(rt+strlen(w1)+p2+1, w2+p2);

    puts(rt);
}

EDYCJA: Dzięki sugestii feersum zaoszczędziłem 54 bajty. = D.

Python 2, 364 352 269 251 bajtów

EDYCJA: Dziękuję bardzo @Cyoce za pomoc w golfa 83 bajtów!

Proszę, pomóż mi w golfa! W każdym razie przynajmniej jestem pierwszym odpowiadającym na Pythona. Mam nadzieję, że uda mi się pokonać Javę, jeśli kiedykolwiek pojawi się odpowiedź w języku Java!

i=input()
f=l=''
A='aeiou'
for j in A:
 I=i[0];J=I.find(j)
 if ~J:
  if f:
   if f>I[0][:J]:f=I[:J];break
  else:f=I[:J]
for j in A:
 Y=i[1];J=Y.find(j)
 if ~J:
  if l:
   if l>Y[:J]:l=Y[:J];break
  else:l=Y[:J]
print I.replace(f,l,1),Y.replace(l,f,1)

Wypróbuj tutaj

Japt, 26 25 bajtów

Na szczęście dodałem klasę samogłoski do wyrażeń regularnych Japt kilka dni temu. Niestety nie dodałem klasy nie-samogłoskowej ani nie omijałem podwójnych ukośników odwrotnych w ciągach wyrażeń regularnych.

#¿s4 £Uf"[^\\v]+|.+
?" gX

¿Powinna być surowa char U + 0093. Dane wejściowe są łańcuchem wieloliniowym, jednym słowem / linią. Wypróbuj online!

EDYCJA: Dodałem teraz klasę \Vinną niż samogłoska i obejście \\(z %), więc ten kod działa teraz dla 21 bajtów : ( Wypróbuj online )

#¿s4 £Uf"%V+|.+
?" gX

Jak to działa

                     // Implicit: U = input string
#¿s4                 // Convert the char code (147) into a base-4 string "2103".
     £               // Map each char X in this string to:
      Uf"[^\\v]+|.+  //  Match each group in U of non-vowels or non-newlines,
?"                   //  with an optional trailing newline.
   gX                //  Get the item at position X in the resulting array.
                     // Implicit: output last expression

Stara wersja (26 bajtów):

UrA="\\b[^\\v ]+"@UfA gÂ!Y

Wypróbuj online!

Jak to działa

UrA="\\b[^\\v ]+"@UfA gÂ!Y  // Implicit: U = input string
  A="\\b[^\\v ]+"           // Set variable A to this regex string, which matches
                            // a word boundary followed by one or more non-vowels.
UrA              @          // Take U and replace each match X of A and its index Y with:
                  UfA       //  Take U.match(A).
                      gÂ!Y  //  Get the item at index ~~!Y (converts 0 to 1, anything else to 0).
                            // Implicit: output last expression

Python 3, 100 (lub 99) bajtów

import re
def f(*g):a,b=[re.split("[aeiou]",r)[0] for r in g];return b+g[0][len(a):],a+g[1][len(b):]

Grałem z kilkoma wersjami, ale wydaje się, że nie można go znaleźć poniżej. Można go zmniejszyć o 99 bajtów, używając def f(g)zamiast tego, więc zajmuje listę ciągów zamiast dwóch oddzielnych ciągów, ale wolę dwa argumenty.

Alternatywą jest równa długość:

import re
s=re.split
def f(x,y):v="[aeiou]";a,b=s(v,x)[0],s(v,y)[0];return b+x[len(a):],a+y[len(b):]

Próbowałem zastąpić, jak używa @TanMath, ale nie mogłem go skrócić. Ponadto TanMath może skrócić swoją odpowiedź o bajt, używając również "[aeiou]"zamiast, "[aeiou]+"ponieważ musimy dopasować tylko pojedyncze wystąpienia. Wreszcie, implementacja input()wydaje się zmienić między py2 i py3 - automatycznie ocenia stdin jako ciąg.

sed, 38 znaków

s/([^aeiou]+)(.+ )([^aeiou]+)/\3\2\1/

Używanie rozszerzonego wyrażenia regularnego z rozwiązania Retina .

Powyższe ma 37 znaków i wymaga -rprzełącznika (znak +1).

Przykład:

$ cat input | tee /dev/tty | sed -r 's/([^aeiou]+)(.+ )([^aeiou]+)/\3\2\1/'
plaster man
blushing crow
litigating more
strong wrangler
def ghi
master plan
crushing blow
mitigating lore
wrong strangler
ghef di

C # 6, 165 bajtów

string S(string a,string b){int i=V(a),j=V(b);return b.Remove(j)+a.Substring(i)+" "+a.Remove(i)+b.Substring(j);}int V(string s)=>s.IndexOfAny("aeiou".ToCharArray());

Rozszerzony:

string S(string a,string b){
    int i=V(a),
        j=V(b);
    return b.Remove(j)+a.Substring(i)+" "+a.Remove(i)+b.Substring(j);
}
int V(string s)=>s.IndexOfAny("aeiou".ToCharArray());

𝔼𝕊𝕄𝕚𝕟, 24 znaki / 42 bajty

ïē/⟮(⁅ᶌ]+)⟯(.+ )Ⅰ/,`⑶⑵⑴`

Try it here (Firefox only).

Jeśli potrzebujesz pomocy w zrozumieniu tego, przekłada się to na ES6 as

input.replace(/([^aeiou]+)(.+ )([^aeiou]+)/g,'$3$2$1')

PowerShell, 52 bajty

"$args "-replace('(.*?)([aeiou]\S+) '*2),'$3$2 $1$4'

e.g. 
PS C:\scripts\> .\Spoonerise.ps1 'blushing crow'
crushing blow

Jest to wyrażenie regularne z czterema grupami przechwytywania; z:

• Mnożenie ciągów w celu rozwinięcia:
  • ('(.*?)([aeiou]\S+) '*2) do '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• "$args "Siły tablica args w ciągu, i dodaje spacją więc przestrzeń spływu w regex nie złamie go.

JavaScript (ES6), 120 107 102 101 99 92 bajtów

• Dzięki upaat!

Uwzględnia to, czy parametry były obiektem takim jak ten i odwrotnie:
var a = {x: "man", y:"plaster"]}

a.b=(e=>e.slice(e.search`[aeiou]`));with(a){c=b(x),d=b(y),x=x.replace(c,d);y=y.replace(d,c)}

Python, 129 108 105 109 bajtów

Ten program pobiera listę takich słów ["master","plan"]

EDYCJA : Dzięki @Volatility

EDYCJA: Teraz używa re.split

import re
a=re.split
c='[aeiou]+'
i,j=input()
f=a(c,i)[0]
l=a(c,j)[0]
print i.replace(f,l,1),j.replace(l,f,1)

Ta odpowiedź używa wyrażenia regularnego, jak większość z nich.

Wypróbuj tutaj

Java 8, 343 bajtów

Tutaj masz swoją pierwszą odpowiedź Java. Nie tak doświadczony z golfem, więc każda sugestia jest mile widziana!

java.util.function.Function;public class C{public static void main(String[] a){Function<String, Integer>f=s->{for(int i=0;i<s.length();++i)if("aeiou".contains(s.substring(i,i+1)))return i;return 0;};int i1=f.apply(a[0]),i2=f.apply(a[1]);System.out.println(a[1].substring(0,i2)+a[0].substring(i1)+" "+a[0].substring(0,i1)+a[1].substring(i2));}}

Nie golfowany:

public class SpooneriseWords {
    public static void main(String[] args)
    {       
        Function<String, Integer> f = s -> {
            for(int i = 0; i < s.length(); ++i)
                if("aeiou".contains(s.substring(i, i + 1))) 
                    return i;
            return 0;
        };

        int i1 = f.apply(args[0]);
        int i2 = f.apply(args[1]);
        System.out.println(args[1].substring(0, i2) + args[0].substring(i1));
        System.out.println(args[0].substring(0, i1) + args[1].substring(i2));
    }
}

Oktawa, 96 bajtów

Dzięki wbudowanym funkcjom Octave i funkcji „indeksu w dowolnym miejscu” cała ta definicja jest tylko definicją pojedynczej, anonimowej funkcji. Zasadniczo rekonstruujemy spłaszczony ciąg, przechowując punkty odcięcia w ai b. Szczególnie cieszę się z ffunkcji inline , która znajduje punkt odcięcia i uniemożliwiła mi find(ismember(a,b),1)dwukrotne użycie całej tej rzeczy. Również brak wyrażenia regularnego :) .

@(p,q)[q(1:(a=(f=@(m)find(ismember(m,'aeoui'),1))(q))-1),p(b=f(q):end),32,p(1:b-1),q(a:end)];

TeaScript , 27 bajtów

xg/(\w+)(.+ )(\w+)/,"$3$2$1

\wjest właściwie [^aeiou].

Eliksir ,143 117 bajtów

s=fn w->String.split_at(w,elem(hd(Regex.run(~r/[aeiou]/,w,return: :index)),0))end
{v,w}=s.(a)
{x,y}=s.(b)
[x<>w,v<>y]

Podziel dwa ciągi (a, b) na pierwszej samogłosce i skonstruuj nowe ciągi, aby powrócić.

EDYCJA: Odciąłem kilka bajtów, używając dopasowania wzorca zamiast nieporęcznych elemwywołań, aby uzyskać wartości z krotek.

Java, 147 bajtów

Zakładam, że tylko funkcja jest w porządku.

String s(String[]i){String r="[aeiou]",f=i[0].split(r)[0],s=i[1].split(r)[0];return s+i[0].substring(f.length())+" "+f+i[1].substring(s.length());}

split(regex)niestety zużywa ogranicznik, co oznacza, że ​​muszę użyć substringprzyrostków.

Pyth, 30 28 bajtów

Pobiera dane wejściowe i podaje dane wyjściowe jako listę dwóch słów.

ACm,Kh:d"[aeiou]"3.-dKQ+V_GH

Wypróbuj online.

Python (bez wyrażeń regularnych), 85 bajtów

t=lambda s:s[1]in'aeiou'or-~t(s[1:])
lambda a,b:(b[:t(b)]+a[t(a):],a[:t(a)]+b[t(b):])

Przykładowy przebieg:

>>> t=lambda s:s[1]in'aeiou'or-~t(s[1:])
>>> lambda a,b:(b[:t(b)]+a[t(a):],a[:t(a)]+b[t(b):])
<function <lambda> at 0x7f495e534398>
>>> _('plaster', 'man')
('master', 'plan')

tjest funkcją rekurencyjną, która oblicza indeks najwcześniejszej samogłoski po pierwszym znaku w argumencie s. Jeśli drugi znak s[1]jest samogłoską, ocenia True, która ma intwartość 1. W przeciwnym razie wykonuje rekurencyjne wywołanie z usuniętym pierwszym znakiem i dodaje 1 do wynikowego indeksu za pomocą -~(uzupełnienie dwóch uzupełnień jednego). Wreszcie, wyniki tsą używane jako wskaźniki do krojenia łańcuchów w celu obliczenia łyżki.

GNU Awk 4.0, 48 znaków

split($0,a,/\<[^aeiou]+/,s)&&$0=s[2]a[2]s[1]a[3]

Przykładowy przebieg:

bash-4.3$ for s in 'plaster man' 'blushing crow' 'litigating more' 'strong wrangler' 'def ghi'; do
>     echo -n "$s -> "
>     awk 'split($0,a,/\<[^aeiou]+/,s)&&$0=s[2]a[2]s[1]a[3]' <<< "$s"
> done
plaster man -> master plan
blushing crow -> crushing blow
litigating more -> mitigating lore
strong wrangler -> wrong strangler
def ghi -> ghef di

PowerShell, 61 bajtów

"$args"-replace'([^aeiou]+)(.*)\s([^aeiou]+)(.*)','$3$2 $1$4'

Używa wyrażenia regularnego do zamiany pierwszych znaków każdego słowa bez samogłoski