Dadas dos palabras, cucharearlas cambiando sus grupos de consonantes iniciales. Pocos bytes ganan.

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

Las consonantes que aparecen antes de la primera vocal ( aeiou) se cambian.

Entrada: Dos cadenas en minúsculas que comienzan con diferentes consonantes y cada una contiene una vocal aeiou.

Salida: las dos cadenas de cuchara, en el orden correcto.

Para entrada y / o salida, las dos cadenas también pueden estar en una lista o similar, o como una sola cadena con 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:**

Esto es casi un engaño de esta vieja pregunta , pero espero escribir una especificación que sea más clara y estable para que el viejo pueda cerrarse como un engaño .

Vim, 18 pulsaciones de teclas

/[aeiou]<CR>dbwvnhp0P

El truco crucial es que pegar algo en el modo Visual en realidad coloca el contenido anterior de la selección visual en el búfer de pegado.

brainfuck, 238 207 bytes

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

Requiere ,devolver 0 en EOF, celdas de ajuste de 8 bits y la capacidad de moverse hacia la izquierda desde la celda 0. En mi experiencia, estas son las configuraciones predeterminadas más comunes.

Estoy bastante feliz con este. Mi primer intento fue de 314 bytes y esto es sin duda una mejora. :)

Funciona almacenando cada byte desde la entrada en dos celdas; uno con el valor real del byte y el otro con la salida del siguiente código cuando se proporciona (el valor del byte - 97):

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

Si el carácter es una consonante, sale de eso con un valor distinto de cero. Si es una vocal, se convierte en 0. A partir de ahí, solo es cuestión de encontrar dónde comienza la segunda palabra e imprimir todo en orden.

La versión de 238 bytes de este programa encontró el carácter de espacio después de recopilar toda la entrada. Fue un dolor de cabeza porque hacerlo implicaba crear una celda que contenía 0 justo donde estaba tratando de recorrerlo. La forma en que resolví eso tuvo el efecto de restar 30 de cada carácter en la primera palabra y 32 de cada carácter después de ella. Una porción bastante grande del código se dedicó a manejar esas tonterías.

Ahora, 32 se resta de cada carácter en el bucle de entrada, que es más corto y tiene un efecto secundario similar que es más fácil de manejar. Como beneficio adicional, hacerlo de esta manera me permitió crear mi propio personaje espacial de una manera más corta: en lugar de restar 139 de 171 (171 es lo que obtienes cuando pasas un espacio a través del detector de vocales anterior), el bucle que suma 32 cada personaje se sale de su camino para agregar también 32 a la celda 171. Esto cuesta cuatro bytes allí, pero significa que puedo restar 171 más tarde (en lugar de restar 139) para un total neto de 3 bytes guardados.

Con comentarios:

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

Me pregunto si vim es realmente competitivo en este desafío. Probablemente no con los idiomas de golf, pero tal vez con 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)

Pruébelo en línea en Ideone .

Cómo funciona

La cadena del patrón se repite tres veces ( *3), lo que resulta en el patrón

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

Todas las instancias coincidirán con una cadena no vacía de no vocales, o una cadena no vacía seguida de un solo carácter de espacio.

La primera instancia coincidirá con las consonantes al comienzo de la primera palabra. Como +es codicioso, intentará igualar la mayor cantidad posible, es decir, todo hasta la primera vocal.

Debido a esto, la segunda instancia comenzará en una vocal, por lo que coincidirá con el resto de la primera palabra, hasta e incluyendo el espacio que separa las palabras.

De manera similar a la primera instancia, la tercera coincidirá con todas las consonantes al comienzo de la segunda palabra, lo que dará como resultado una coincidencia exitosa para todo el patrón.

La cadena sin formato \3\2\1( revita que Python reemplace, \3etc., con caracteres de control) invierte el orden de las coincidencias de los patrones entre paréntesis, es decir, los reemplaza con las consonantes al comienzo de la segunda palabra, luego todos los caracteres de la primera vocal de la primera palabra hasta el espacio, y finalmente las consonantes al comienzo de la primera palabra.

El argumento final para sub( 1) hace que regrese inmediatamente después del primer reemplazo exitoso, para evitar reemplazos sin sentido en el resto de la segunda palabra. Esto es necesario ya que el patrón puede coincidir con cualquier cadena de tres o más consonantes consecutivas.

JavaScript (ES6), 54 bytes

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

Explicación

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
  )

Prueba

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

(Sin uso de expresiones regulares)

Esta función espera entrada a través de 2 argumentos, por ejemplo f('blushing','crow'). Devuelve las nuevas palabras en una 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

Hay muchas soluciones de expresiones regulares, así que quería escribir algo que no usara la biblioteca de Python.

Cómo funciona

La única parte complicada es la expresión lambda S(la abreviatura significa " S plit antes de la primera vocal"). Se "itera" recursivamente sobre la palabra dada, moviendo un carácter a la vez desde el principio de s(que comienza con la palabra completa) hasta el final de p(que comienza vacío). En la primera vocal encontrada devuelve (p,s), es decir (prefijo, sufijo). ¡Observe que ese es el orden incorrecto en comparación con los parámetros!

Pensé que tenía más sentido que el orden devuelto fuera prefijo, luego sufijo (porque generalmente un prefijo va antes que un sufijo). Este orden puede hacer que el a,b=S(x)código sea un poco más fácil de leer.

Pero no tenía opción de orden en los parámetros de la lambda, por lo que no podía definir pantes s. El primer parámetro, s, tuvo que tomar la palabra completa, porque ptenía un valor por defecto, y los parámetros por defecto ir pasado. Al hacer eso, no necesité llamar a la función Scon una cadena vacía dos veces, y se pudieron guardar algunos bytes. Sin embargo, quizás fue simplemente una mala decisión devolver el prefijo / sufijo en el orden opuesto, ya que se utilizó dentro de la expresión lambda.

En cuanto a la elección de la expresión lambda sobre la función, se necesita más bytes que decir def S(s,p=""):returnque S=lambda s,p="":. Puedo hacer esa elección porque Python tiene evaluación de cortocircuito y el operador ternario. Sin embargo, no puedo explicar adecuadamente cómo usé los cortocircuitos; Es difícil razonar sobre eso.

Esta es mi primera respuesta. Espero haberlo hecho correctamente y que valga la pena publicar una solución que no pueda ganar.

Ediciones: Comentarios de agradecimiento: se redujo el recuento de bytes un poco, dos veces, y se eliminó la información innecesaria. Intentó mejorar la escritura. Ojalá no haya cometido errores.

C # 6, 115 bytes

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

Es un dolor que el espacio de nombres para la expresión regular sea tan largo.

CJam, 27 24 22 bytes

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

I / O es una palabra por línea. Pruébalo en línea!

Cómo 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/

El código anterior tiene 32 bytes de longitud y requiere el -pconmutador ( +1 byte ).

La sustitución es muy similar a la respuesta Retina de @ DigitalTrauma , pero esta respuesta aprovecha los subpatrones recursivos de PCRE .

Pruébelo en línea en Ideone .

Retina , 34

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

Pruébalo en línea.

JavaScript ES6, 93 58 52 bytes

¡Guardado 6 bytes gracias a ETHProductions!

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

¡Pruébalo! (Solo 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

No veo muchas respuestas C por aquí, así que disfrútenlo; Además, golf por primera vez, sugerencias y críticas son bienvenidas.

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

Si no se requiere main (), podemos guardar 24 bytes, llegando 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);}

Sin golf:

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

EDITAR: Gracias a la sugerencia de feersum, ahorré 54 bytes. = D

Python 2, 364 352 269 251 bytes

EDITAR: ¡ Muchas gracias a @Cyoce por ayudarme a jugar golf 83 bytes!

¡Por favor, ayúdame a jugar golf! De todos modos, al menos soy el primer respondedor de Python. ¡Y espero poder vencer a Java, si alguna vez hay una respuesta de 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)

Pruébalo aquí

Japt, 26 25 bytes

Afortunadamente, agregué una clase de vocal a las funciones de expresión regular de Japt hace unos días. Desafortunadamente, no agregué una clase sin vocales o una forma de evitar las barras invertidas dobles en las cadenas de expresiones regulares.

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

El ¿debe ser el char en bruto U + 0093. La entrada es una cadena de varias líneas, una palabra / línea. Pruébalo en línea!

EDITAR: ahora he agregado la clase sin vocal \Vy una forma de evitarlo \\(con %), por lo que este código ahora funciona para 21 bytes : ( Pruébelo en línea )

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

Cómo 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

Versión anterior (26 bytes):

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

Pruébalo en línea!

Cómo 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 (o 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):]

Jugué con algunas versiones, pero parece que no puedo obtenerlo a continuación. Puede bajarlo 99 bytes usando en su def f(g)lugar, por lo que toma una lista de cadenas en lugar de dos cadenas separadas, pero prefiero las dos arg argue.

La alternativa es la misma longitud:

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

Intenté reemplazar, como los usos de @TanMath, pero no pude hacerlo más corto. Además, TanMath puede acortar su respuesta en un byte al usarla en "[aeiou]"lugar de hacerlo "[aeiou]+"porque solo necesitamos hacer coincidir las instancias individuales. Finalmente, la implementación de input()parece haber cambiado entre py2 y py3: evalúa automáticamente stdin como una cadena.

sed, 38 caracteres

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

Usando la expresión regular extendida de la solución Retina .

Lo anterior tiene 37 caracteres y requiere el -rcambio (+1 carácter).

Ejemplo:

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

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

Try it here (Firefox only).

Si necesita ayuda para comprender esto, esto se traduce en 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

Es una regex reemplazada con cuatro grupos de captura; con:

• Multiplicación de cadenas para expandir:
  • ('(.*?)([aeiou]\S+) '*2) a '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• La "$args "fuerzas de la matriz args en una cadena, y añade un espacio al final por lo que el espacio al final de la expresión regular no romperlo.

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

• Gracias downgoat!

Esto tiene en cuenta si los parámetros eran un objeto como este, y hacia atrás:
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 incluye una lista de palabras como esta ["master","plan"]

EDITAR : Gracias @Volatility

EDITAR: ahora 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 respuesta usa expresiones regulares como la mayoría de ellas.

Pruébalo aquí

Java 8, 343 bytes

Aquí tienes tu primera respuesta Java. No es tan experimentado con el golf, por lo que se agradece cualquier sugerencia.

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

Sin golf:

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

Octava, 96 bytes

Gracias a las asignaciones en línea de Octave y la funcionalidad de 'indexar en cualquier lugar', todo esto es solo la definición de una única función anónima. Básicamente, reconstruimos la cuerda cuchara mientras almacenamos los puntos de corte en ay b. Estoy especialmente contento con la ffunción en línea , que encuentra el punto de corte, y me impidió tener que usar todo el proceso find(ismember(a,b),1)dos veces. Además, no 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

\wes en realidad [^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 las dos cadenas (a, b) en la primera vocal y construya nuevas cadenas para regresar.

EDITAR: Obtuve unos pocos bytes usando la coincidencia de patrones en lugar de elemllamadas torpes para obtener los valores de las tuplas.

Java, 147 bytes

Supongo que solo una función también está bien.

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)lamentablemente consume el delimitador, lo que significa que tengo que usar substringpara obtener los sufijos.

Pyth, 30 28 bytes

Toma entrada y da salida como una lista de las dos palabras.

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

Pruébalo en línea.

Python (sin expresiones regulares), 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):])

Ejecución de muestra:

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

tes una función recursiva que calcula el índice de la vocal más temprana después del primer carácter en su argumento s. Si el segundo carácter s[1]es una vocal, se evalúa como True, que tiene intvalor 1. De lo contrario, realiza una llamada recursiva con el primer carácter eliminado y agrega 1 al índice resultante usando -~(complemento de dos del complemento de uno). Finalmente, los resultados de tse usan como índices para el corte de cuerdas para calcular el cuchara.

GNU Awk 4.0, 48 caracteres

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

Ejecución de muestra:

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'

Utiliza expresiones regulares para intercambiar los primeros caracteres no vocales de cada palabra