Учитывая два слова, ложите их в ложку , переключая их начальные группы согласных. Побеждает несколько байтов.

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

Согласные, появляющиеся перед первым гласным ( aeiou), переключаются.

Входные данные: две строчные буквы, начинающиеся с разных согласных и содержащие гласные aeiou.

Вывод: две строки в ложке, в правильном порядке.

Для ввода и / или вывода две строки также могут быть в списке и т.п. или в виде одной строки с разделителем.

    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:**

Это почти дурацкий ответ на этот старый вопрос , но я надеюсь написать спецификацию, которая будет более ясной и стабильной, чтобы старый можно было закрыть как дурак .

Vim, 18 нажатий клавиш

/[aeiou]<CR>dbwvnhp0P

Важный трюк заключается в том, что вставка чего-либо в визуальном режиме фактически помещает старое содержимое визуального выделения в буфер вставки.

бред, 238 207 байт

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

Требует ,возврата 0 для EOF, 8-битных оберточных ячеек и способности двигаться влево от ячейки 0. По моему опыту, это наиболее распространенные настройки по умолчанию.

Я очень доволен этим. Моя первая попытка была 314 байтов, и это, безусловно, улучшение. :)

Он работает, сохраняя каждый байт от ввода в двух ячейках; один с действительным значением байта, а другой с выводом следующего кода, если дано (значение байта - 97):

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

Если символ является согласной, он получается с ненулевым значением. Если это гласный, он становится 0. Оттуда просто нужно найти, где начинается второе слово и напечатать все по порядку.

238-байтовая версия этой программы нашла пробел после сбора всех входных данных. Это была головная боль, потому что это включало в себя создание ячейки, содержащей 0, там, где я пытался зациклить ее. Способ, который я решил, позволил вычесть 30 из каждого символа в первом слове и 32 из каждого символа после него. Довольно большая часть кода была посвящена обработке этой чепухи.

Теперь 32 вычитается из каждого символа в цикле ввода, который короче и имеет похожий побочный эффект, с которым легче иметь дело. В качестве бонуса, выполнение этого способа позволило мне создать свой собственный космический символ более коротким способом: вместо того, чтобы вычитать 139 из 171 (171 - это то, что вы получаете, когда вы пробуете пробел через детектор гласных выше), цикл, который добавляет 32 чтобы каждый персонаж старался изо всех сил добавить 32 к 171 ячейке. Это стоит там четыре байта, но это означает, что я могу вычесть из него 171 позже (вместо того, чтобы вычесть 139) для чистой общей суммы сэкономленных 3 байтов.

С комментариями:

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

Интересно, действительно ли vim конкурентоспособен в этом соревновании? Вероятно, не с языками игры в гольф, но, возможно, с Ruby / Python / Perl / и т.д.

/[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 байт

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

Попробуйте онлайн на Ideone .

Как это устроено

Строка шаблона повторяется трижды ( *3), в результате чего шаблон

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

Все экземпляры будут либо совпадать с непустой строкой не гласных, либо с непустой строкой, за которой следует один пробел.

Первый экземпляр будет соответствовать согласным в начале первого слова. Поскольку +он жадный, он будет пытаться сопоставить как можно больше, т. Е. Все, вплоть до первого гласного.

Из-за этого второй экземпляр будет начинаться с гласного, поэтому он будет соответствовать оставшейся части первого слова, вплоть до пробела, который разделяет слова.

Как и в первом случае, третий будет соответствовать всем согласным в начале второго слова, что приведет к успешному совпадению для всего шаблона.

Необработанная строка \3\2\1( rпредотвращает замену Python \3и т. Д. Управляющими символами) меняет порядок совпадений шаблонов в скобках, т. Е. Заменяет их согласными в начале второго слова, а затем все символы из первого гласного слова первое слово до пробела и, наконец, согласные в начале первого слова.

Последний аргумент to sub( 1) заставляет его возвращаться сразу после первой успешной замены, чтобы избежать бессмысленных замен в оставшейся части второго слова. Это необходимо, поскольку шаблон может соответствовать любой строке из трех или более последовательных согласных.

JavaScript (ES6), 54 байта

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

объяснение

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
  )

Контрольная работа

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 байт

(Не использовать регулярные выражения)

Эта функция ожидает ввода через 2 аргумента, например f('blushing','crow'). Возвращает новые слова в кортеже.

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

Существует множество решений для регулярных выражений, поэтому я хотел написать что-то, что не использовало бы библиотеку Python.

Как это устроено

Единственной сложной частью является лямбда-выражение S(аббревиатура означает « S plit перед первым гласным»). Он рекурсивно «перебирает» данное слово, перемещая по одному символу за раз от начала s(который начинается со всего слова) до конца p(который начинается пустым). При первой обнаруженной гласной она возвращает (p,s), т.е. (префикс, суффикс). Обратите внимание, что это неправильный порядок по сравнению с параметрами!

Я подумал, что для возвращаемого ордера имеет больше смысла префикс, а не суффикс (потому что обычно префикс идет перед суффиксом). Этот порядок может a,b=S(x)немного облегчить чтение кода.

Но у меня не было выбора порядка в параметрах лямбды, поэтому я не мог определить pраньше s. Первый параметр s, должен был взять слово целиком , потому что pимел значение по умолчанию и параметры по умолчанию идут в последнюю очередь . Для этого мне не нужно было Sдважды вызывать функцию с пустой строкой, и можно было бы сохранить несколько байтов. Однако, возможно, это было просто плохое решение вернуть префикс / суффикс в обратном порядке, поскольку он использовался в лямбда-выражении.

Что касается выбора лямбда-выражения над функцией, то требуется больше байтов, чтобы сказать, def S(s,p=""):returnчем S=lambda s,p="":. Я могу сделать этот выбор, потому что Python имеет оценку короткого замыкания и троичный оператор. Однако я не могу адекватно объяснить, как я использовал короткие замыкания; это трудно рассуждать.

Это мой первый ответ. Я надеюсь, что я сделал это правильно, и что стоит опубликовать решение, которое не может победить.

Редактирование: Спасибо, комментаторы: Немного, вдвое уменьшил количество байтов и удалил ненужную информацию. Попытка улучшить написание. Надеюсь, не ошибся.

C # 6, 115 байт

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

Это просто боль, пространство имен для регулярных выражений так долго.

CJam, 27 24 22 байта

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

Ввод / вывод - одно слово в строке. Попробуйте онлайн!

Как это устроено

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 байта

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

Вышеприведенный код имеет длину 32 байта и требует -pпереключения ( +1 байт ).

Подстановка очень похожа на ответ Retina на @ DigitalTrauma , но в этом ответе используются рекурсивные субпаттерны PCRE .

Попробуйте онлайн на Ideone .

Сетчатка , 34

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

Попробуйте онлайн.

JavaScript ES6, 93 58 52 байта

Сохранено 6 байтов благодаря ETHProductions!

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

Проверь это! (Только 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 байт

Я не вижу здесь много ответов на C, так что наслаждайтесь; Кроме того, впервые в гольф, предложения и критика приветствуются.

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

Если main () не требуется, мы можем сохранить 24 байта, получив 179 байтов

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

Ungolfed:

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

РЕДАКТИРОВАТЬ: Благодаря предложению Feersum я сэкономил 54 байта. = D

Python 2, 364 352 269 251 байт

РЕДАКТИРОВАТЬ: Большое спасибо @Cyoce за помощь мне в гольф 83 байта!

Пожалуйста, помогите мне в этом! Во всяком случае, по крайней мере, я первый ответчик Python. И я надеюсь, что смогу победить Java, если когда-нибудь будет ответ 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)

Попробуй здесь

Japt, 26 25 байт

К счастью, я добавил класс гласных в функции регулярных выражений Japt несколько дней назад. К сожалению, я не добавил не-гласный класс или обход двойных обратных косых черт в строках регулярных выражений.

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

¿Должна быть сырой символ U + 0093. Ввод - многострочная строка, одно слово / строка. Попробуйте онлайн!

РЕДАКТИРОВАТЬ: я теперь добавил не гласный класс \Vи обходной путь \\(с %), так что этот код теперь работает для 21 байта : ( Попробуйте онлайн )

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

Как это устроено

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

Старая версия (26 байт):

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

Попробуйте онлайн!

Как это устроено

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 (или 99) байтов

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

Поиграл с несколькими версиями, но не могу получить его ниже. def f(g)Вместо этого можно уменьшить его на 99 байтов, чтобы он занял список строк, а не две отдельные строки, но я предпочитаю два аргумента.

Альтернатива равна длине:

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

Я пытался заменить, как @TanMath использует, но я не мог получить его короче. Кроме того, TanMath может сократить свой ответ на байт, также используя "[aeiou]"вместо, "[aeiou]+"потому что нам нужно только сопоставить отдельные экземпляры. Наконец, реализация input()py2 изменилась между py2 и py3 - он автоматически оценивает stdin как строку.

sed, 38 знаков

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

Использование расширенного регулярного выражения из решения Retina .

Длина выше составляет 37 символов и требует -rпереключения (+1 символ).

Пример:

$ 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 байт

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

Expanded:

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 символа / 42 байта

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

Try it here (Firefox only).

Если вам нужна помощь в понимании этого, это переводит ES6 как

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

PowerShell, 52 байта

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

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

Это регулярное выражение заменить четырьмя группами захвата; с участием:

• Умножение строк для расширения:
  • ('(.*?)([aeiou]\S+) '*2) в '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• "$args "Силы массив арг в строку, и добавляет косую пространство так , тянущееся пространство в регулярном выражении не будет нарушать его.

JavaScript (ES6), 120 107 102 101 99 92 байта

• Спасибо, вниз!

Это учитывает, если параметры были объектом, подобным этому, и назад:
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 байт

Эта программа принимает список слов, как это ["master","plan"]

РЕДАКТИРОВАТЬ : Спасибо @ Volollity

РЕДАКТИРОВАТЬ: теперь с помощью 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)

Этот ответ использует регулярные выражения, как и большинство из них.

Попробуй здесь

Java 8, 343 байта

Здесь у вас есть ваш первый Java-ответ. Не то, чтобы опыт игры в гольф, поэтому каждое предложение ценится!

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

Ungolfed:

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

Октава, 96 байт

Благодаря встроенным назначениям Octave и функциональности «index -where», все это всего лишь определение одной анонимной функции. По сути, мы восстанавливаем нанизанную строку, сохраняя точки отсечения в aи b. Я особенно доволен встроенной fфункцией, которая находит точку отсечения и не позволяет мне дважды использовать всю find(ismember(a,b),1)вещь. Кроме того, нет регулярных выражений :) .

@(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 байт

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

\wна самом деле [^aeiou].

Эликсир ,143 117 байт

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]

Разделите две строки (a, b) на первом гласном и создайте новые строки для возврата.

РЕДАКТИРОВАТЬ: получил несколько байтов, используя сопоставление с образцом вместо неуклюжих elemвызовов, чтобы получить значения из кортежей.

Java, 147 байт

Я предполагаю, что просто функция тоже хорошо.

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)к сожалению, потребляет разделитель, что означает, что я должен использовать, substringчтобы получить суффиксы.

Pyth, 30 28 байт

Принимает ввод и выдает вывод в виде списка двух слов.

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

Попробуйте онлайн.

Python (без регулярных выражений), 85 байт

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

Образец прогона:

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

tявляется рекурсивной функцией, которая вычисляет индекс самой ранней гласной после первого символа в своем аргументе s. Если второй символ s[1]является гласным, он оценивается как True, что имеет intзначение 1. В противном случае он выполняет рекурсивный вызов с удалением первого символа и добавляет 1 к результирующему индексу, используя -~(дополнение двух к одному дополнению). Наконец, результаты tиспользуются в качестве индексов для нарезки строк для вычисления ложности.

GNU Awk 4.0, 48 символов

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

Образец прогона:

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 байт

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

Использует регулярное выражение для замены первых не гласных символов каждого слова