Dadas duas palavras, misture -as alternando seus conjuntos de consoantes iniciais. Menos bytes ganha.

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

As consoantes que aparecem antes da primeira vogal ( aeiou) são trocadas.

Entrada: duas seqüências em minúsculas que começam com consoantes diferentes e cada uma contém uma vogal aeiou.

Saída: as duas cordas com colher, na ordem certa.

Para entrada e / ou saída, as duas seqüências também podem estar em uma lista ou similar, ou como uma única sequência com separador.

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

Isso é quase uma bobagem dessa pergunta antiga , mas espero escrever uma especificação que seja mais clara e estável, para que a antiga possa ser fechada como uma bobagem .

Vim, 18 pressionamentos de tecla

/[aeiou]<CR>dbwvnhp0P

O truque crucial é que colar algo no modo Visual, na verdade, coloca o conteúdo antigo da seleção visual no buffer de colagem.

brainfuck, 238 207 bytes

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

Requer ,retornar 0 no EOF, células de quebra automática de 8 bits e a capacidade de mover para a esquerda da célula 0. Na minha experiência, essas são as configurações padrão mais comuns.

Estou muito feliz com este. Minha primeira tentativa foi de 314 bytes e isso certamente é uma melhoria. :)

Ele funciona armazenando todos os bytes da entrada em duas células; um com o valor real do byte e o outro com a saída do seguinte código quando fornecido (o valor do byte - 97):

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

Se o personagem é uma consoante, resulta disso com um valor diferente de zero. Se for uma vogal, ela se torna 0. A partir daí, é apenas uma questão de descobrir onde a segunda palavra começa e imprimir tudo em ordem.

A versão de 238 bytes deste programa encontrou o caractere de espaço após coletar toda a entrada. Foi uma dor de cabeça porque isso envolvia a criação de uma célula que continha 0 exatamente onde eu estava tentando fazer um loop sobre ela. A maneira como resolvi isso teve o efeito de subtrair 30 de cada caractere na primeira palavra e 32 de cada caractere a seguir. Uma parte bastante grande do código foi dedicada a lidar com esse absurdo.

Agora, 32 é subtraído de cada caractere no loop de entrada, que é mais curto e tem um efeito colateral semelhante, mais fácil de lidar. Como bônus, fazê-lo dessa maneira me permitiu criar meu próprio personagem espacial de uma maneira mais curta: em vez de subtrair 139 de 171 (171 é o que você obtém quando passa um espaço pelo detector de vogais acima), o loop que adiciona 32 para cada caractere se esforça para adicionar 32 à célula 171. Isso custa quatro bytes, mas significa que posso subtrair 171 dele mais tarde (em vez de subtrair 139) para um total líquido de 3 bytes salvos.

Com comentários:

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

Gostaria de saber se o vim é realmente competitivo nesse desafio. Provavelmente não com as linguagens de golfe, mas talvez com 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 bytes

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

Experimente online no Ideone .

Como funciona

A sequência do padrão é repetida três vezes ( *3), resultando no padrão

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

Todas as instâncias corresponderão a uma sequência não vazia de vogais ou a uma sequência não vazia seguida por um único caractere de espaço.

A primeira instância corresponderá às consoantes no início da primeira palavra. Como +é ganancioso, ele tentará combinar o maior número possível, ou seja, tudo até a primeira vogal.

Por esse motivo, a segunda instância começará em uma vogal, correspondendo ao restante da primeira palavra, incluindo o espaço que separa as palavras.

De maneira semelhante à primeira instância, a terceira corresponderá a todas as consoantes no início da segunda palavra, resultando em uma correspondência bem-sucedida para todo o padrão.

A cadeia bruta \3\2\1( rimpede que o Python substitua \3etc. pelos caracteres de controle) reverte a ordem das correspondências dos padrões entre parênteses, ou seja, substitui-os pelas consoantes no início da segunda palavra, depois todos os caracteres da primeira vogal da primeira palavra até o espaço e, finalmente, as consoantes no início da primeira palavra.

O argumento final para sub( 1) faz com que ele retorne imediatamente após a primeira substituição bem-sucedida, para evitar substituições sem sentido no restante da segunda palavra. Isso é necessário, pois o padrão pode corresponder a qualquer sequência de três ou mais consoantes consecutivas.

JavaScript (ES6), 54 bytes

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

Explicação

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
  )

Teste

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 bytes

(Sem uso de regex)

Esta função espera entrada através de 2 argumentos, por exemplo f('blushing','crow'). Retorna as novas palavras em uma tupla.

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

Existem muitas soluções regex, então eu queria escrever algo que não usasse a re-biblioteca do Python.

Como funciona

A única parte complicada é a expressão lambda S(a abreviação significa " S plit antes da primeira vogal"). Ele "itera" recursivamente sobre a palavra especificada, movendo um caractere de cada vez desde o início de s(que começa com a palavra inteira) até o final de p(que começa vazio). Na primeira vogal encontrada, ela retorna (p,s), ou seja, (prefixo, sufixo). Observe que essa é a ordem errada em comparação com os parâmetros!

Eu pensei que fazia mais sentido que a ordem retornada fosse prefixo e sufixo (porque geralmente um prefixo precede um sufixo). Esse pedido pode a,b=S(x)facilitar a leitura do código.

Mas eu não tinha escolha de ordem nos parâmetros do lambda, então não pude definir pantes s. O primeiro parâmetro, s, teve de tomar a palavra inteira, porque ptinha um valor padrão e parâmetros padrão ir passado. Fazendo isso, não precisei chamar a função Scom uma string vazia duas vezes e alguns bytes poderiam ser salvos. No entanto, talvez tenha sido simplesmente uma má decisão retornar o prefixo / sufixo na ordem oposta, pois foi usado na expressão lambda.

Quanto à escolha da expressão lambda sobre a função, são necessários mais bytes para dizer def S(s,p=""):returnque S=lambda s,p="":. Posso fazer essa escolha porque o Python possui avaliação de curto-circuito e o operador ternário. No entanto, não sei explicar adequadamente como usei curto-circuito; é difícil argumentar.

Esta é a minha primeira resposta. Espero ter feito isso corretamente e que haja valor em postar uma solução que não possa vencer.

Edições: comentaristas de agradecimento: reduziu a contagem de bytes um pouco, duas vezes e removeu informações desnecessárias. Tentativa de melhorar a escrita. Espero que não tenha cometido erros.

C # 6, 115 bytes

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

É uma pena que o espaço de nomes para regex seja tão longo.

CJam, 27 24 22 bytes

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

E / S é uma palavra por linha. Experimente online!

Como funciona

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 bytes

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

O código acima tem 32 bytes e requer a -popção ( +1 byte ).

A substituição é muito semelhante à resposta Retina do DigitalTrauma , mas essa resposta tira proveito dos subpadrões recursivos do PCRE .

Experimente online no Ideone .

Retina , 34

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

Experimente online.

JavaScript ES6, 93 58 52 bytes

Guardado 6 bytes graças a ETHProductions!

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

Teste-o! (Somente 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 bytes

Não vejo muitas respostas em C por aqui, então aproveite; Além disso, golfe pela primeira vez, sugestões e críticas são bem-vindas.

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

Se main () não for necessário, podemos salvar 24 bytes, chegando a 179 bytes

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

EDIT: Graças à sugestão de feersum eu salvei 54 bytes. = D

Python 2, 364 352 269 251 bytes

EDIT: Muito obrigado a @Cyoce por me ajudar a golfe 83 bytes!

Por favor me ajude a jogar isso! Enfim, pelo menos eu sou o primeiro respondedor do Python. E espero poder vencer o Java, se houver uma resposta do 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)

Experimente aqui

Japonês, 26 25 bytes

Felizmente, adicionei uma classe de vogal aos recursos de regex de Japt há alguns dias. Infelizmente, não adicionei uma classe que não seja vogal ou uma maneira de contornar as barras invertidas duplas nas seqüências de caracteres regex.

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

A ¿deve ser o carvão em bruto L + 0,093. A entrada é uma sequência de várias linhas, uma palavra / linha. Experimente online!

EDIT: Agora eu adicionei a classe que não é vogal \Ve uma maneira de contornar \\(com %), então esse código agora funciona para 21 bytes : ( Experimente on-line )

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

Como funciona

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

Versão antiga (26 bytes):

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

Experimente online!

Como funciona

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 (ou 99) bytes

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

Jogado com algumas versões, mas não consigo obtê-lo abaixo. É possível reduzi-lo em 99 bytes usando, em def f(g)vez disso, é necessária uma lista de seqüências de caracteres em vez de duas seqüências separadas, mas eu prefiro os dois argumentos de argumento.

A alternativa é igual:

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

Tentei substituir, como o @TanMath usa, mas não consegui obtê-lo mais curto. Além disso, o TanMath pode obter sua resposta mais curta em um byte usando também em "[aeiou]"vez de, "[aeiou]+"porque precisamos apenas corresponder às instâncias únicas. Finalmente, a implementação de input()parece ter mudado entre py2 e py3 - ela avalia automaticamente stdin como uma string.

sed, 38 caracteres

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

Usando expressão regular estendida da solução Retina .

O texto acima tem 37 caracteres e requer a -rtroca (+1).

Exemplo:

$ 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 bytes

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

Expandido:

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, 24 caracteres / 42 bytes

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

Try it here (Firefox only).

Se você precisar de ajuda para entender isso, isso se traduz no ES6 como

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

PowerShell, 52 bytes

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

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

É uma substituição de regex por quatro grupos de captura; com:

• Multiplicação de string para expandir:
  • ('(.*?)([aeiou]\S+) '*2) para '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• A "$args "forças da matriz args em uma string, e adiciona um espaço à direita de modo que o espaço à direita na regex não vai quebrá-lo.

JavaScript (ES6), 120 107 102 101 99 92 bytes

• Graças downgoat!

Isso leva em consideração se os parâmetros eram um objeto como esse e vice-versa:
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 bytes

Este programa contém uma lista de palavras como esta ["master","plan"]

EDIT : Obrigado @Volatility

EDIT: agora usando 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)

Esta resposta usa regex como a maioria deles.

Experimente aqui

Java 8, 343 bytes

Aqui você tem sua primeira resposta Java. Não é tão experiente no golfe, então todas as sugestões são apreciadas!

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

Oitava, 96 bytes

Graças às atribuições em linha do Octave e à funcionalidade "indexar em qualquer lugar", tudo isso é apenas a definição de uma única função anônima. Basicamente, reconstruímos a corda com colher enquanto armazenamos os pontos de corte em ae b. Estou especialmente feliz com a ffunção inline , que encontra o ponto de corte e me impediu de usar a find(ismember(a,b),1)coisa toda duas vezes. Além disso, sem regex :) .

@(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 bytes

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

\wé realmente [^aeiou].

Elixir ,143 117 bytes

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]

Divida as duas cordas (a, b) na primeira vogal e construa novas cordas para retornar.

EDIT: Obteve alguns bytes usando a correspondência de padrões em vez de elemchamadas desajeitadas para obter os valores das tuplas.

Java, 147 bytes

Estou assumindo que apenas uma função está bem também.

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)infelizmente consome o delimitador, o que significa que tenho que usar substringpara obter os sufixos.

Pitão, 30 28 bytes

Recebe entrada e fornece saída como uma lista das duas palavras.

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

Experimente online.

Python (sem regexes), 85 bytes

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

Exemplo de execução:

>>> 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é uma função recursiva que calcula o índice da vogal mais antiga após o primeiro caractere em seu argumento s. Se o segundo caractere s[1]for uma vogal, ele avalia como True, que tem intvalor 1. Caso contrário, ele faz uma chamada recursiva com o primeiro caractere removido e adiciona 1 ao índice resultante usando -~(complemento de dois do complemento de alguém). Finalmente, os resultados de tsão usados ​​como índices para o corte de cordas para calcular o Spoerism.

GNU Awk 4.0, 48 caracteres

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

Exemplo de execução:

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 bytes

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

Usa regex para trocar os primeiros caracteres não vogais de cada palavra