Étant donné deux mots, spoonerise- les en changeant leurs groupes de consonnes initiales. Le moins d'octets gagne.

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

Les consonnes apparaissant avant la première voyelle ( aeiou) sont commutées.

Entrée: deux chaînes en minuscules qui commencent par des consonnes différentes et contiennent chacune une voyelle aeiou.

Sortie: Les deux chaînes spoonérisées, dans le bon ordre.

Pour l’entrée et / ou la sortie, les deux chaînes peuvent également être dans une liste ou similaire, ou sous la forme d’une chaîne unique avec séparateur.

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

Ceci est une quasi-dupe de cette vieille question , mais j'espère écrire une spécification plus claire et plus stable afin que l'ancienne puisse être fermée comme une dupe .

Vim, 18 frappes

/[aeiou]<CR>dbwvnhp0P

L'astuce cruciale est que coller sur quelque chose en mode visuel place en réalité l'ancien contenu de la sélection visuelle dans la mémoire tampon de collage.

brainfuck, 238 207 octets

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

Nécessite ,de renvoyer 0 sur EOF, des cellules d'habillage de 8 bits et la possibilité de se déplacer à gauche de la cellule 0. D'après mon expérience, ce sont les paramètres par défaut les plus courants.

Je suis assez content de celui-ci. Mon premier essai était de 314 octets et c'est certainement une amélioration. :)

Cela fonctionne en stockant chaque octet de l'entrée dans deux cellules; l'un avec la valeur réelle de l'octet et l'autre avec la sortie du code suivant lorsqu'il est indiqué (la valeur de l'octet - 97):

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

Si le caractère est une consonne, il en sort avec une valeur non nulle. Si c'est une voyelle, il devient 0. À partir de là, il suffit de trouver où commence le deuxième mot et de tout imprimer dans l'ordre.

La version de 238 octets de ce programme a trouvé le caractère d'espace après avoir collecté toutes les entrées. C'était un casse-tête parce que cela impliquait de créer une cellule contenant 0 exactement là où j'essayais de passer en boucle. La façon dont j'ai résolu le problème avait pour effet de soustraire 30 de chaque caractère du premier mot et 32 ​​de chaque caractère après celui-ci. Une partie assez importante du code était dédiée à la gestion de ce non-sens.

Maintenant, 32 caractères sont soustraits de chaque caractère de la boucle de saisie, ce qui est plus court et a un effet secondaire similaire, mais plus facile à gérer. En prime, cela m'a permis de créer mon propre caractère d'espace plus rapidement: au lieu de soustraire 139 à 171 (171 est ce que vous obtenez lorsque vous passez un espace à travers le détecteur de voyelles ci-dessus), la boucle qui ajoute 32 à chaque personnage se met en quatre pour ajouter également 32 à la cellule 171. Cela coûte quatre octets, mais cela signifie que je peux en soustraire 171 plus tard (au lieu de 139) pour un total net de 3 octets sauvés.

Avec des commentaires:

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

Je me demande si vim est réellement compétitif dans ce défi. Probablement pas avec les langues de golf, mais peut-être avec 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 octets

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

Essayez-le en ligne sur Ideone .

Comment ça fonctionne

La chaîne de motif est répétée trois fois ( *3), ce qui entraîne le motif

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

Toutes les occurrences correspondront soit à une chaîne non vide de non-voyelles, soit à une chaîne non vide suivie d'un caractère d'espacement unique.

La première instance correspondra aux consonnes au début du premier mot. Étant donné qu'il +est gourmand, il essaiera de faire correspondre le plus grand nombre possible, c'est-à-dire jusqu'à la première voyelle.

Pour cette raison, la deuxième instance commencera par une voyelle, elle correspondra donc au reste du premier mot, jusqu'à l'espace compris entre les mots.

Comme dans le premier cas, le troisième correspondra à toutes les consonnes au début du deuxième mot, ce qui donnera une correspondance réussie pour le motif entier.

La chaîne brute \3\2\1( rempêche Python de remplacer, \3etc., avec des caractères de contrôle) inverse l'ordre des correspondances des motifs entre parenthèses, c'est-à-dire qu'elle les remplace par les consonnes au début du second mot, puis tous les caractères de la première voyelle du mot. premier mot jusqu'à l'espace, et enfin les consonnes au début du premier mot.

L'argument final de sub( 1) le fait revenir immédiatement après le premier remplacement réussi, afin d'éviter des remplacements insensés dans le reste du deuxième mot. Cela est nécessaire car le modèle peut correspondre à n’importe quelle chaîne de trois consonnes consécutives ou plus.

JavaScript (ES6), 54 octets

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

Explication

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
  )

Tester

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 octets

(Pas d'utilisation de regex)

Cette fonction attend une entrée via 2 arguments, par exemple f('blushing','crow'). Renvoie les nouveaux mots dans un tuple.

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

Il y a beaucoup de solutions regex, je voulais donc écrire quelque chose qui n'utilise pas la bibliothèque re de Python.

Comment ça fonctionne

La seule partie compliquée est l'expression lambda S(l'abréviation signifie " S plit avant la première voyelle"). Il "récursive" sur le mot donné, en déplaçant un caractère à la fois du début de s(qui commence par le mot entier) à la fin de p(qui commence vide). À la première voyelle rencontrée, il retourne (p,s), c'est-à-dire (préfixe, suffixe). Notez que ce n'est pas le bon ordre par rapport aux paramètres!

J'ai pensé qu'il était plus logique que l'ordre renvoyé soit préfixe, puis suffixe (car généralement, un préfixe est placé avant un suffixe). Cette commande peut rendre le a,b=S(x)code légèrement plus facile à lire.

Mais je n'avais pas le choix de l'ordre dans les paramètres du lambda, donc je ne pouvais pas définir pavant s. Le premier paramètre, s, a dû prendre le mot entier , car pavait une valeur par défaut, et les paramètres par défaut à la dernière. En faisant cela, je n'avais pas besoin d'appeler la fonction Savec une chaîne vide deux fois, et quelques octets pouvaient être sauvegardés. Cependant, il était peut-être simplement une mauvaise décision de renvoyer préfixe / suffixe dans l'ordre inverse de celui utilisé dans l'expression lambda.

En ce qui concerne le choix de l'expression lambda sur la fonction, il faut plus d'octets à dire def S(s,p=""):returnque S=lambda s,p="":. Je peux faire ce choix car Python a une évaluation de court-circuit et l’opérateur ternaire. Cependant, je ne peux pas expliquer correctement comment j'ai utilisé les courts-circuits; il est difficile de raisonner.

Ceci est ma première réponse. J'espère l'avoir fait correctement et qu'il est utile de publier une solution qui ne peut pas gagner.

Modifications: Merci aux commentateurs: le nombre d'octets a été réduit un peu, deux fois et les informations inutiles ont été supprimées. Tenté d'améliorer l'écriture. Si tout va bien fait aucune erreur.

C # 6, 115 octets

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

C'est juste une douleur l'espace de noms pour regex est si long.

CJam, 27 24 22 octets

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

I / O est un mot par ligne. Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Le code ci-dessus a une longueur de 32 octets et nécessite le -pcommutateur ( +1 octet ).

La substitution est très similaire à celle donnée par @ @ DigitalTrauma dans Retina , mais cette réponse tire parti des sous -modèles récursifs de PCRE .

Essayez-le en ligne sur Ideone .

Rétine , 34 ans

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

Essayez-le en ligne.

JavaScript ES6, 93 58 52 octets

Sauvegardé 6 octets grâce à ETHProductions!

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

Essaye-le! (ES6 seulement)

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 octets

Je ne vois pas beaucoup de réponses C ici, alors profitez-en; De plus, les golfeurs débutants, suggestions et critiques sont les bienvenus.

#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 main () n'est pas requis, nous pouvons économiser 24 octets et atteindre 179 octets.

#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: Grâce à la suggestion de Feersum, j'ai économisé 54 octets. = D

Python 2, 364 352 269 251 octets

EDIT: Merci beaucoup à @Cyoce de m'avoir aidé à jouer au golf 83 octets!

S'il vous plaît, aidez-moi à jouer au golf! Quoi qu'il en soit, au moins, je suis le premier répondeur Python. Et j'espère que je peux battre Java, s'il y a une réponse 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)

Essayez-le ici

Japt, 26 25 octets

Heureusement, j'ai ajouté une classe de voyelles à la fonctionnalité regex de Japt il y a quelques jours. Malheureusement, je n'ai pas ajouté de classe non-voyelle ni de contournement des doubles barres obliques inverses dans les chaînes regex.

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

Le ¿devrait être le caractère brut U + 0093. L'entrée est une chaîne de plusieurs lignes, un mot / ligne. Essayez-le en ligne!

EDIT: J'ai maintenant ajouté la classe non-voyelle \Vet un moyen de contourner \\(avec %), donc ce code fonctionne maintenant pour 21 octets : ( Essayez-le en ligne )

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

Comment ça fonctionne

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

Ancienne version (26 octets):

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

Essayez-le en ligne!

Comment ça fonctionne

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

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

Joué avec quelques versions mais ne semble pas pouvoir l'obtenir ci-dessous. On peut obtenir 99 octets en utilisant def f(g)plutôt une liste de chaînes plutôt que deux chaînes séparées, mais je préfère les deux arg roue.

L'alternative est égale à la longueur:

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

J'ai essayé de remplacer, comme @TanMath utilise, mais je ne pouvais pas le faire plus court. En outre, TanMath peut obtenir une réponse plus courte d'un octet en utilisant également à la "[aeiou]"place de "[aeiou]+"parce que nous n'avons besoin que de faire correspondre les instances uniques. Enfin, l'implémentation de input()semble avoir changé entre py2 et py3 - elle évalue automatiquement stdin en tant que chaîne.

sed, 38 personnages

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

Utilisation de l'expression régulière étendue de la solution Retina .

Ce qui précède est de 37 caractères et nécessite le -rchangement (+1 caractère).

Exemple:

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

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

Étendu:

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 caractères / 42 octets

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

Try it here (Firefox only).

Si vous avez besoin d’aide pour comprendre cela, cela se traduit en ES6 par

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

PowerShell, 52 octets

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

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

C'est une regex à remplacer par quatre groupes de capture; avec:

• Multiplication de chaîne à développer:
  • ('(.*?)([aeiou]\S+) '*2) à '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• Les "$args "forces du tableau args dans une chaîne, et ajoute un espace de fuite si l'espace de fuite dans le regex ne le casser.

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

• Merci downgoat!

Ceci prend en compte si les paramètres étaient un objet comme celui-ci et inversement:
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 octets

Ce programme prend dans une liste de mots comme celui-ci ["master","plan"]

EDIT : Merci @Volatility

EDIT: utilise maintenant 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)

Cette réponse utilise regex comme le font la plupart d'entre eux.

Essayez-le ici

Java 8, 343 octets

Ici vous avez votre première réponse Java. Pas aussi expérimenté avec le golf, chaque suggestion est appréciée!

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

Octave, 96 octets

Grâce aux attributions en ligne d'Octave et à la fonctionnalité "index-Anywhere", tout cela n'est que la définition d'une seule fonction anonyme. Fondamentalement, nous reconstruisons la chaîne spoonerized tout en stockant les points de coupure dans aet b. Je suis particulièrement satisfait de la ffonction inline , qui trouve le point de coupure et m'empêche d'utiliser le "tout" à find(ismember(a,b),1)deux reprises. En outre, pas de 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 octets

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

\west en fait [^aeiou].

Elixir ,143 117 octets

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]

Fractionner les deux chaînes (a, b) sur la première voyelle et construire de nouvelles chaînes à renvoyer.

EDIT: Quelques octets ont été supprimés en utilisant une correspondance de modèle au lieu d' elemappels maladroits pour extraire les valeurs des tuples.

Java, 147 octets

Je suppose que juste une fonction est bien aussi.

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)consomme malheureusement le délimiteur, ce qui signifie que je dois utiliser substringpour obtenir les suffixes.

Pyth, 30 28 octets

Prend une entrée et donne la sortie sous forme de liste des deux mots.

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

Essayez-le en ligne.

Python (sans regex), 85 octets

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

Échantillon échantillon:

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

test une fonction récursive qui calcule l'indice de la voyelle la plus ancienne après le premier caractère de son argument s. Si le deuxième caractère s[1]est une voyelle, il est évalué à True, ce qui a une intvaleur 1. Sinon, il effectue un appel récursif avec le premier caractère supprimé et ajoute 1 à l'index résultant en utilisant -~(complément à deux du complément). Enfin, les résultats de tsont utilisés comme indices pour le découpage de chaînes afin de calculer le spoonérisme.

GNU Awk 4.0, 48 caractères

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

Échantillon échantillon:

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 octets

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

Utilise regex pour échanger les premiers caractères non-voyelles de chaque mot