Con due parole, rovesciatele cambiando i loro gruppi di consonanti iniziali. Vince il minor numero di byte.

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

Le consonanti che appaiono prima della prima vocale ( aeiou) vengono scambiate.

Input: due stringhe minuscole che iniziano con consonanti diverse e contengono ciascuna una vocale aeiou.

Output: le due stringhe spatolate, nell'ordine giusto.

Per input e / o output, le due stringhe possono anche essere in un elenco o simili, oppure come una singola stringa con separatore.

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

Questo è quasi un duplicato di questa vecchia domanda , ma spero di scrivere una specifica che sia più chiara e più stabile in modo che quella vecchia possa essere chiusa come una copia .

Vim, 18 battute

/[aeiou]<CR>dbwvnhp0P

Il trucco cruciale è che incollare qualcosa in modalità Visual mette effettivamente i vecchi contenuti della selezione visiva nel buffer di incollaggio.

brainfuck, 238 207 byte

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

Richiede ,di restituire 0 su EOF, celle a capo a 8 bit e la possibilità di spostarsi a sinistra dalla cella 0. Nella mia esperienza, queste sono le impostazioni predefinite più comuni.

Sono abbastanza contento di questo. Il mio primo tentativo è stato di 314 byte e questo è sicuramente un miglioramento. :)

Funziona memorizzando ogni byte dall'input in due celle; uno con il valore effettivo del byte e l'altro con l'output del codice seguente quando indicato (il valore del byte - 97):

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

Se il personaggio è una consonante, ne esce con un valore diverso da zero. Se è una vocale, diventa 0. Da lì è solo una questione di trovare dove inizia la seconda parola e stampare tutto in ordine.

La versione a 238 byte di questo programma ha trovato il carattere spazio dopo aver raccolto tutti gli input. Era un mal di testa perché farlo comportava la creazione di una cella che conteneva 0 proprio nel punto in cui stavo cercando di passarci sopra. Il modo in cui ho risolto ha avuto l'effetto di sottrarre 30 da ogni personaggio nella prima parola e 32 da ogni personaggio successivo. Una parte abbastanza grande del codice era dedicata alla gestione di queste sciocchezze.

Ora, 32 viene sottratto da ogni personaggio nel ciclo di input, che è più breve e ha un effetto collaterale simile che è più facile da gestire. Come bonus, farlo in questo modo mi ha permesso di creare il mio personaggio spaziale in un modo più breve: invece di sottrarre 139 da 171 (171 è quello che ottieni quando corri uno spazio attraverso il rilevatore di vocali sopra), il ciclo che aggiunge 32 ad ogni personaggio fa di tutto per aggiungere anche 32 alla cella 171. Questo costa quattro byte lì, ma significa che posso sottrarre 171 da esso in seguito (invece di sottrarre 139) per un totale netto di 3 byte salvati.

Con commenti:

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

Mi chiedo se vim sia effettivamente competitivo in questa sfida. Probabilmente non con le lingue del golf, ma forse con Ruby / Python / Perl / ecc.

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

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

Provalo online su Ideone .

Come funziona

La stringa del motivo viene ripetuta tre volte ( *3), risultando nel motivo

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

Tutte le istanze corrisponderanno a una stringa non vuota di non vocali oppure a una stringa non vuota seguita da un singolo carattere spazio.

La prima istanza corrisponderà alle consonanti all'inizio della prima parola. Poiché +è avido, tenterà di abbinare il maggior numero possibile, vale a dire, tutto fino alla prima vocale.

Per questo motivo, la seconda istanza inizierà in una vocale, quindi corrisponderà al resto della prima parola, fino allo spazio incluso che separa le parole.

Analogamente alla prima istanza, la terza corrisponderà a tutte le consonanti all'inizio della seconda parola, risultando in una corrispondenza corretta per l'intero modello.

La stringa non elaborata \3\2\1( rimpedisce a Python di sostituire \3ecc. Con caratteri di controllo) inverte l'ordine delle corrispondenze dei motivi tra parentesi, ovvero le sostituisce con le consonanti all'inizio della seconda parola, quindi tutti i caratteri della prima vocale della prima parola fino allo spazio, e infine le consonanti all'inizio della prima parola.

L'argomento finale di sub( 1) lo fa restituire immediatamente dopo la prima sostituzione riuscita, per evitare sostituzioni senza senso nel resto della seconda parola. Ciò è necessario poiché il modello può corrispondere a qualsiasi stringa di tre o più consonanti consecutive.

JavaScript (ES6), 54 byte

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

Spiegazione

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 byte

(Nessun uso di regex)

Questa funzione prevede input tramite 2 argomenti, ad es f('blushing','crow'). Restituisce le nuove parole in 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

Ci sono molte soluzioni regex, quindi volevo scrivere qualcosa che non usasse la libreria di Python.

Come funziona

L'unica parte complicata è l'espressione lambda S(l'abbreviazione significa " S plit prima della prima vocale"). Ricorre in modo ricorsivo alla parola data, spostando un carattere alla volta dall'inizio di s(che inizia con l'intera parola) alla fine di p(che inizia a vuoto). Alla prima vocale incontrata ritorna (p,s), cioè (prefisso, suffisso). Si noti che è un ordine sbagliato rispetto ai parametri!

Ho pensato che avesse più senso che l'ordine restituito fosse prefisso, quindi suffisso (perché generalmente un prefisso precede un suffisso). Questo ordine potrebbe rendere il a,b=S(x)codice leggermente più semplice da leggere.

Ma non avevo scelta dell'ordine nei parametri della lambda, quindi non potevo definire pprima s. Il primo parametro, s, doveva prendere l'intera parola, perché pha avuto un valore di default, e parametri di default andare scorso. In questo modo, non avevo bisogno di chiamare la funzione Scon una stringa vuota due volte e alcuni byte potevano essere salvati. Tuttavia, forse è stata semplicemente una cattiva decisione di restituire prefisso / suffisso nell'ordine opposto in quanto è stato utilizzato nell'espressione lambda.

Per quanto riguarda la scelta dell'espressione lambda rispetto alla funzione, ci vogliono più byte per dire def S(s,p=""):returndi S=lambda s,p="":. Posso fare questa scelta perché Python ha una valutazione del corto circuito e l'operatore ternario. Tuttavia, non posso spiegare adeguatamente come ho usato i cortocircuiti; è difficile ragionare su.

Questa è la mia prima risposta Spero di averlo fatto correttamente e che sia utile pubblicare una soluzione che non può vincere.

Modifiche: commentatori di ringraziamento: ridotto il conteggio dei byte un po ', due volte e rimosso informazioni non necessarie. Tentativo di migliorare la scrittura. Spero non abbia fatto errori.

C # 6, 115 byte

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

È solo un dolore lo spazio dei nomi per regex è così lungo.

CJam, 27 24 22 byte

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

L'I / O è una parola per riga. Provalo online!

Come funziona

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 byte

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

Il codice sopra è lungo 32 byte e richiede l' -popzione ( +1 byte ).

La sostituzione è molto simile a quella della risposta Retina di @ DigitalTrauma , ma questa risposta sfrutta i sottoprocessi ricorsivi di PCRE .

Provalo online su Ideone .

Retina , 34

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

Provalo online.

JavaScript ES6, 93 58 52 byte

6 byte salvati grazie a ETHProductions!

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

Provalo! (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 byte

Non vedo molte risposte in C qui, quindi divertiti; Inoltre, per la prima volta golf, suggerimenti e critiche sono i benvenuti.

#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 () non è necessario, possiamo salvare 24 byte, arrivando a 179 byte

#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: grazie al suggerimento di feersum ho salvato 54 byte. = D

Python 2, 364 352 269 251 byte

EDIT: Grazie mille a @Cyoce per avermi aiutato a golf 83 byte!

Per favore, aiutami a giocare a golf! Comunque, almeno io sono il primo risponditore di Python. E spero di poter battere Java, se mai c'è una risposta 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)

Provalo qui

Japt, 26 25 byte

Fortunatamente, ho aggiunto una classe vocale alle caratteristiche regex di Japt qualche giorno fa. Sfortunatamente, non ho aggiunto una classe non vocale o un modo per aggirare le doppie barre rovesciate nelle stringhe regex.

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

Il ¿dovrebbe essere il char grezzo U + 0093. L'input è una stringa a più righe, una parola / riga. Provalo online!

EDIT: ora ho aggiunto la classe non vocale \Ve un modo per aggirare \\(con %), quindi questo codice ora funziona per 21 byte : ( Provalo online )

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

Come funziona

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

Vecchia versione (26 byte):

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

Provalo online!

Come funziona

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

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

Giocato con alcune versioni ma non riesco a trovarlo qui sotto. Può ridurlo di 99 byte usando def f(g)invece in modo da prendere un elenco di stringhe piuttosto che due stringhe separate, ma preferisco il roue arg due.

L'alternativa è uguale lunghezza:

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

Ho provato a sostituire, come usa @TanMath, ma non sono riuscito ad accorciarlo. Inoltre, TanMath può accorciare la sua risposta di un byte usando anche "[aeiou]"invece che "[aeiou]+"perché dobbiamo solo abbinare le singole istanze. Infine, l'implementazione di input()sembra essere cambiata tra py2 e py3 - valuta automaticamente lo stdin come una stringa.

sed, 38 caratteri

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

Utilizzo dell'espressione regolare estesa dalla soluzione Retina .

Quanto sopra è lungo 37 caratteri e richiede l' -ropzione (+1 carattere).

Esempio:

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

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

Allargato:

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 caratteri / 42 byte

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

Try it here (Firefox only).

Se hai bisogno di aiuto per capirlo, questo si traduce in ES6 come

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

PowerShell, 52 byte

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

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

È un regex sostitutivo con quattro gruppi di acquisizione; con:

• Moltiplicazione delle stringhe da espandere:
  • ('(.*?)([aeiou]\S+) '*2) per '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• La "$args "forze args in una stringa, e aggiunge uno spazio finale così lo spazio finale nel regex non romperlo.

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

• Grazie downgoat!

Ciò tiene conto se i parametri fossero un oggetto come questo, e indietro:
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 byte

Questo programma contiene un elenco di parole come questa ["master","plan"]

EDIT : Grazie @Volatility

EDIT: ora 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)

Questa risposta usa regex come la maggior parte di loro.

Provalo qui

Java 8, 343 byte

Ecco la tua prima risposta Java. Non così esperto di golf, quindi ogni suggerimento è apprezzato!

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

Ottava, 96 byte

Grazie alle assegnazioni in linea di Octave e alla funzionalità di "indicizzazione ovunque", l'intera cosa è solo la definizione di una singola funzione anonima. Fondamentalmente, ricostruiamo la corda spatolata mentre memorizziamo i punti di taglio in ae b. Sono particolarmente soddisfatto della ffunzione inline , che trova il punto di interruzione e mi ha impedito di dover usare l'intera find(ismember(a,b),1)cosa due volte. Inoltre, nessuna 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 byte

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

\wè in realtà [^aeiou].

Elisir ,143 117 byte

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]

Dividi le due stringhe (a, b) sulla prima vocale e costruisci nuove stringhe per tornare.

EDIT: ottenuto alcuni byte usando la corrispondenza del modello invece di elemchiamate goffe per ottenere i valori dalle tuple.

Java, 147 byte

Suppongo che anche solo una funzione vada bene.

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)purtroppo consuma il delimitatore, il che significa che devo usare substringper ottenere i suffissi.

Pyth, 30 28 byte

Accetta input e fornisce output come un elenco di due parole.

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

Provalo online.

Python (senza regex), 85 byte

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

Esecuzione di esempio:

>>> 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è una funzione ricorsiva che calcola l'indice della prima vocale dopo il primo carattere nel suo argomento s. Se il secondo carattere s[1]è una vocale, valuta True, che ha intvalore 1. Altrimenti effettua una chiamata ricorsiva con il primo carattere rimosso e aggiunge 1 all'indice risultante usando -~(complemento a due del proprio complemento). Infine, i risultati di tvengono utilizzati come indici per lo slicing delle stringhe per calcolare il cucchiaio.

GNU Awk 4.0, 48 caratteri

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

Esecuzione di esempio:

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 byte

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

Usa regex per scambiare i primi caratteri non vocali di ogni parola