Spoonerisieren Sie sie mit zwei gegebenen Wörtern, indem Sie ihre anfänglichen Konsonantencluster wechseln. Wenigste Bytes gewinnt.

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

Die Konsonanten vor dem ersten Vokal ( aeiou) werden gewechselt.

Eingabe: Zwei Kleinbuchstaben, die mit verschiedenen Konsonanten beginnen und jeweils einen Vokal enthalten aeiou.

Ausgabe: Die zwei spoonerisierten Saiten in der richtigen Reihenfolge.

Für die Eingabe und / oder Ausgabe können die beiden Zeichenfolgen auch in einer Liste oder dergleichen oder als einzelne Zeichenfolge mit Trennzeichen vorliegen.

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

Dies ist fast ein Trottel dieser alten Frage , aber ich hoffe, eine Spezifikation zu schreiben, die klarer und stabiler ist, damit die alte als Trottel geschlossen werden kann .

Vim, 18 Tastenanschläge

/[aeiou]<CR>dbwvnhp0P

Der entscheidende Trick besteht darin, dass beim Einfügen von Objekten im visuellen Modus der alte Inhalt der visuellen Auswahl tatsächlich in den Einfügepuffer verschoben wird.

Brainfuck, 238 207 Bytes

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

Erfordert ,die Rückgabe von 0 bei EOF, 8-Bit-Zeilenumbruch und die Möglichkeit, von Zelle 0 nach links zu wechseln. Nach meiner Erfahrung sind dies die häufigsten Standardeinstellungen.

Ich bin ziemlich glücklich mit diesem. Mein erster Versuch war 314 Bytes und das ist sicherlich eine Verbesserung. :)

Es speichert jedes Byte von der Eingabe in zwei Zellen. eines mit dem tatsächlichen Wert des Bytes und das andere mit der Ausgabe des folgenden Codes, wenn angegeben (der Wert des Bytes - 97):

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

Wenn das Zeichen ein Konsonant ist, ergibt sich daraus ein Wert ungleich Null. Wenn es sich um einen Vokal handelt, wird er zu 0. Von dort aus müssen Sie nur herausfinden, wo das zweite Wort beginnt, und alles in der richtigen Reihenfolge ausdrucken.

Die 238-Byte-Version dieses Programms hat das Leerzeichen gefunden, nachdem alle Eingaben gesammelt wurden. Es bereitete mir Kopfschmerzen, weil dabei eine Zelle mit 0 erstellt wurde, genau dort, wo ich versuchte, eine Schleife darüber zu erstellen. Die Art und Weise, wie ich sie gelöst habe, hatte zur Folge, dass 30 von jedem Zeichen im ersten Wort und 32 von jedem Zeichen danach abgezogen wurden. Ein ziemlich großer Teil des Codes war dem Umgang mit diesem Unsinn gewidmet.

Jetzt wird von jedem Zeichen in der Eingabeschleife 32 subtrahiert , was kürzer ist und einen ähnlichen Nebeneffekt hat, mit dem leichter umzugehen ist. Als Bonus konnte ich auf diese Weise mein eigenes Leerzeichen auf kürzere Weise erstellen: Anstatt 139 von 171 zu subtrahieren (171 erhalten Sie, wenn Sie ein Leerzeichen durch den obigen Vokaldetektor laufen lassen), ergibt die Schleife 32 Jedes Zeichen tut alles, um der 171-Zelle 32 hinzuzufügen. Dies kostet dort vier Bytes, bedeutet aber, dass ich 171 davon später subtrahieren kann (anstatt 139 zu subtrahieren), um insgesamt 3 Bytes zu sparen.

Mit Kommentaren:

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

Ich frage mich, ob vim bei dieser Herausforderung konkurrenzfähig ist. Wahrscheinlich nicht mit den Golfsprachen, aber vielleicht mit 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)

Probieren Sie es online auf Ideone .

Wie es funktioniert

Die Musterfolge wird dreimal wiederholt ( *3), was zu dem Muster führt

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

Alle Instanzen stimmen entweder mit einer nicht leeren Folge von Nicht-Vokalen überein oder mit einer nicht leeren Folge, gefolgt von einem einzelnen Leerzeichen.

Die erste Instanz entspricht den Konsonanten am Anfang des ersten Wortes. Da +es gierig ist, wird es versuchen, so viele wie möglich zu finden, dh alle bis zum ersten Vokal.

Aus diesem Grund beginnt die zweite Instanz mit einem Vokal, sodass sie mit dem Rest des ersten Wortes bis einschließlich des Leerzeichens übereinstimmt, das die Wörter trennt.

Ähnlich wie bei der ersten Instanz stimmt die dritte Instanz mit allen Konsonanten am Anfang des zweiten Wortes überein, was zu einer erfolgreichen Übereinstimmung für das gesamte Muster führt.

Die Rohzeichenfolge \3\2\1( rverhindert, dass Python \3usw. durch Steuerzeichen ersetzt) ​​kehrt die Reihenfolge der Übereinstimmungen der in Klammern gesetzten Muster um, dh, sie ersetzt sie durch die Konsonanten am Anfang des zweiten Wortes und dann durch alle Zeichen aus dem ersten Vokal des erstes Wort bis zum Leerzeichen und schließlich die Konsonanten am Anfang des ersten Wortes.

Das letzte Argument für sub( 1) bewirkt, dass es unmittelbar nach dem ersten erfolgreichen Ersetzen zurückgegeben wird, um unsinnige Ersetzungen im Rest des zweiten Wortes zu vermeiden. Dies ist erforderlich, da das Muster mit einer beliebigen Zeichenfolge von drei oder mehr aufeinanderfolgenden Konsonanten übereinstimmen kann.

JavaScript (ES6), 54 Byte

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

Erläuterung

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
  )

Prüfung

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

(Keine Verwendung von Regex)

Diese Funktion erwartet Eingaben über 2 Argumente, z f('blushing','crow'). Gibt die neuen Wörter in einem Tupel zurück.

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

Da es viele reguläre Ausdrücke gibt, wollte ich etwas schreiben, das nicht die reguläre Bibliothek von Python verwendet.

Wie es funktioniert

Der einzig komplizierte Teil ist der Lambda-Ausdruck S(die Abkürzung bedeutet " S plit before the first vokal"). Es "iteriert" rekursiv über das gegebene Wort und bewegt jeweils ein Zeichen vom Anfang s(der mit dem ganzen Wort beginnt) bis zum Ende p(der leer beginnt). Beim ersten angetroffenen Vokal wird zurückgegeben (p,s), dh (Präfix, Suffix). Beachten Sie, dass dies im Vergleich zu den Parametern die falsche Reihenfolge ist!

Ich dachte, es wäre sinnvoller, wenn die zurückgegebene Bestellung ein Präfix und dann ein Suffix ist (da in der Regel ein Präfix vor einem Suffix steht). Diese Reihenfolge kann die Lesbarkeit des a,b=S(x)Codes etwas verbessern.

Aber ich hatte keine Wahl , um in die Parameter des Lambda, so dass ich nicht definieren konnte pvor s. Der erste Parameter s, hatte das ganze Wort zu nehmen , weil pein Standardwert hatte und Standardparameter zuletzt gehen. Dabei musste ich die Funktion nicht Szweimal mit einer leeren Zeichenfolge aufrufen , und einige Bytes konnten gespeichert werden. Vielleicht war es jedoch einfach eine schlechte Entscheidung, das Präfix / Suffix in der entgegengesetzten Reihenfolge zurückzugeben, wie es im Lambda-Ausdruck verwendet wurde.

Für die Wahl des Lambda-Ausdrucks gegenüber der Funktion sind mehr Bytes erforderlich def S(s,p=""):returnals S=lambda s,p="":. Ich kann diese Wahl treffen, weil Python eine Kurzschlussauswertung und den ternären Operator hat. Ich kann jedoch nicht ausreichend erklären, wie ich Kurzschlüsse verwendet habe. Es ist schwer zu überlegen.

Dies ist meine erste Antwort. Ich hoffe, dass ich das richtig gemacht habe und dass es einen Wert hat, eine Lösung zu veröffentlichen, die nicht gewinnen kann.

Änderungen: Dankeschön-Kommentatoren: Die Anzahl der Bytes wurde ein wenig reduziert, zweimal, und unnötige Informationen wurden entfernt. Es wurde versucht, das Schreiben zu verbessern. Hoffentlich keine Fehler gemacht.

C # 6, 115 Bytes

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

Es ist nur ein Schmerz, der Namespace für Regex ist so lang.

CJam, 27 24 22 Bytes

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

I / O ist ein Wort pro Zeile. Probieren Sie es online!

Wie es funktioniert

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/

Der obige Code ist 32 Byte lang und erfordert den -pSchalter ( +1 Byte ).

Die Substitution ist der Retina-Antwort von @ DigitalTrauma sehr ähnlich, nutzt jedoch die rekursiven Submuster von PCRE .

Probieren Sie es online auf Ideone .

Retina , 34

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

Probieren Sie es online aus.

JavaScript ES6, 93 58 52 Bytes

6 Bytes gespart dank ETHProductions!

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

Probier es aus! (Nur 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

Ich sehe hier nicht viele C-Antworten, also viel Spaß. Auch das erste Mal Golfen, Anregungen und Kritik sind willkommen.

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

Wenn main () nicht benötigt wird, können wir 24 Bytes einsparen und 179 Bytes erreichen

#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: Dank Feersums Vorschlag habe ich 54 Bytes gespart. = D

Python 2, 364 352 269 251 Bytes

EDIT: Vielen Dank an @Cyoce für die Hilfe beim Golfen mit 83 Bytes!

Bitte hilf mir Golf zu spielen! Jedenfalls bin ich der erste Python-Beantworter. Und ich hoffe, ich kann Java schlagen, wenn es jemals eine Java-Antwort gibt!

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)

Probieren Sie es hier aus

Japt, 26 25 Bytes

Glücklicherweise habe ich vor ein paar Tagen Japts Regex-Funktionen um eine Vokal-Klasse erweitert. Leider habe ich keine Nicht-Vokal-Klasse oder einen Weg um die doppelten Backslashes in Regex-Strings hinzugefügt.

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

Das ¿sollte das Rohzeichen U + 0093 sein. Die Eingabe ist eine mehrzeilige Zeichenfolge, ein Wort / eine Zeile. Probieren Sie es online!

BEARBEITEN: Ich habe jetzt die Nicht-Vokal-Klasse \Vund einen Weg um \\(mit %) hinzugefügt , so dass dieser Code jetzt für 21 Bytes funktioniert : ( Online ausprobieren )

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

Wie es funktioniert

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

Alte Version (26 Bytes):

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

Probieren Sie es online!

Wie es funktioniert

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

Spielte mit ein paar Versionen, scheint es aber nicht zu verstehen. Kann 99 Bytes reduzieren, indem def f(g)stattdessen eine Liste von Zeichenfolgen anstelle von zwei separaten Zeichenfolgen verwendet wird, aber ich bevorzuge die beiden Argumente.

Die Alternative ist gleich lang:

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

Ich habe versucht zu ersetzen, wie es @ TanMath verwendet, aber ich konnte es nicht kürzer bekommen. Außerdem kann TanMath seine Antwort um ein Byte kürzer machen, indem er "[aeiou]"stattdessen auch verwendet, "[aeiou]+"weil wir nur die einzelnen Instanzen abgleichen müssen. Schließlich input()scheint sich die Implementierung von zwischen py2 und py3 geändert zu haben - stdin wird automatisch als String ausgewertet.

sed, 38 zeichen

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

Verwendung eines erweiterten regulären Ausdrucks aus der Retina-Lösung .

Das obige ist 37 Zeichen lang und erfordert den -rSchalter (+1 Zeichen).

Beispiel:

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

Erweitert:

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 Zeichen / 42 Byte

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

Try it here (Firefox only).

Wenn Sie Hilfe benötigen, um dies zu verstehen, wird dies in ES6 als übersetzt

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

Es ist ein regulärer Ausdruck, der durch vier Erfassungsgruppen ersetzt wird. mit:

• String-Multiplikation zum Erweitern:
  • ('(.*?)([aeiou]\S+) '*2) zu '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• Das "$args "erzwingt die Bildung eines Strings aus dem args-Array und fügt ein nachfolgendes Leerzeichen hinzu, damit das nachfolgende Leerzeichen in der Regex es nicht unterbricht.

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

• Vielen Dank downgoat!

Dies berücksichtigt, ob die Parameter ein Objekt wie dieses sind und umgekehrt:
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

Dieses Programm nimmt eine Liste solcher Wörter auf ["master","plan"]

EDIT : Danke @Volatility

EDIT: Jetzt mit 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)

In dieser Antwort wird wie in den meisten Fällen Regex verwendet.

Probieren Sie es hier aus

Java 8, 343 Bytes

Hier haben Sie Ihre erste Java-Antwort. Nicht so viel Erfahrung mit Golfspielen, daher wird jeder Vorschlag geschätzt!

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

Oktave, 96 Bytes

Dank der Inline-Zuweisungen von Octave und der "Index-Anywhere" -Funktionalität ist dieses Ganze nur die Definition einer einzelnen anonymen Funktion. Grundsätzlich rekonstruieren wir die spoonerized Zeichenfolge während die abgeschnittenen Punkte in Speichern aund b. Ich bin besonders zufrieden mit der Inline- fFunktion, die den Cut-Off-Punkt findet und verhindert, dass ich das find(ismember(a,b),1)Ganze zweimal verwenden muss. Auch kein 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

\wist eigentlich [^aeiou].

Elixier ,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]

Teilen Sie die beiden Zeichenfolgen (a, b) im ersten Vokal auf und konstruieren Sie neue Zeichenfolgen für die Rückkehr.

BEARBEITEN: Ein paar Bytes weniger mit Pattern Matching anstatt mit klobigen elemAufrufen, um die Werte aus den Tupeln herauszuholen.

Java, 147 Bytes

Ich gehe davon aus, dass nur eine Funktion auch in Ordnung ist.

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)Leider verbraucht der Begrenzer, was bedeutet, dass ich verwenden muss substring, um die Suffixe zu erhalten.

Pyth, 30 28 Bytes

Übernimmt die Eingabe und gibt die Ausgabe als Liste der beiden Wörter aus.

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

Probieren Sie es online aus.

Python (keine regulären Ausdrücke), 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):])

Probelauf:

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

tist eine rekursive Funktion, die den Index des frühesten Vokals nach dem ersten Zeichen in ihrem Argument berechnet s. Wenn das zweite Zeichen s[1]ein Vokal ist, wird es zu ausgewertet True, der intWert hat 1. Andernfalls wird ein rekursiver Aufruf ausgeführt, bei dem das erste Zeichen entfernt wird, und dem resultierenden Index wird mit -~(Zweierkomplement des eigenen Komplements) eine 1 hinzugefügt. Schließlich werden die Ergebnisse von tals Indizes für das Aufteilen von Zeichenfolgen verwendet, um den Spoonerismus zu berechnen.

GNU Awk 4.0, 48 Zeichen

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

Probelauf:

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'

Verwendet Regex, um die ersten Nicht-Vokalzeichen jedes Wortes auszutauschen