두 단어가 주어지면 초기 자음 클러스터를 전환하여 그것들을 채우십시오 . 가장 적은 바이트가 이깁니다.

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

첫 모음 ( aeiou) 전에 나타나는 자음 이 전환됩니다.

입력 : 다른 자음으로 시작하고 각각 모음을 포함하는 두 개의 소문자 문자열 aeiou.

출력 : 올바른 순서로 두 개의 숟가락 모양의 줄.

입력 및 / 또는 출력을 위해, 2 개의 스트링은 또한리스트 등으로 또는 분리기를 갖는 단일 스트링으로 존재할 수있다.

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

이것은 이 오래된 질문 의 거의 속임수 이지만 , 이전의 내용을 속임수로 닫을 수 있도록보다 명확하고 안정적인 사양을 작성하고 싶습니다 .

Vim, 18 번의 키 입력

/[aeiou]<CR>dbwvnhp0P

중요한 트릭은 비주얼 모드에서 무언가를 붙여 넣으면 실제로 시각적 선택의 오래된 내용을 붙여 넣기 버퍼에 넣는 것입니다.

브레인 퍽, 238 207 바이트

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

,EOF, 8 비트 랩핑 셀 및 셀 0에서 왼쪽으로 이동할 수있는 기능에서 0을 반환 해야 합니다. 제 경험상 가장 일반적인 기본 설정입니다.

나는 이것에 매우 만족합니다. 내 첫 번째 시도는 314 바이트 였고 이것은 확실히 개선되었습니다. :)

입력의 모든 바이트를 두 셀에 저장하여 작동합니다. 하나는 바이트의 실제 값을 가지며 다른 하나는 주어진 경우 다음 코드의 출력을 나타냅니다 (바이트 값-97).

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

문자가 자음 인 경우 0이 아닌 값에서 나옵니다. 모음이면 0이됩니다. 거기에서 두 번째 단어가 시작되는 곳을 찾아 모든 것을 순서대로 인쇄하면됩니다.

이 프로그램의 238 바이트 버전은 모든 입력을 수집 한 후 공백 문자를 찾았습니다. 루프를 반복하려고하는 곳에 0이 들어있는 셀을 만드는 것이 복잡했기 때문에 두통이었습니다. 내가 해결 한 방식은 첫 단어의 모든 문자에서 30을 빼고 그 뒤의 모든 문자에서 32를 빼는 효과가있었습니다. 코드의 상당 부분이 그 말도 안되는 것을 처리하는 데 전념했습니다.

이제 입력 루프의 모든 문자 에서 32를 빼면 더 짧아지고 다루기 쉬운 유사한 부작용이 있습니다. 보너스 로이 방법을 사용하면 더 짧은 방법으로 내 자신의 공간 문자를 만들 수 있습니다 .171에서 139를 빼는 대신 (171은 위의 모음 감지기를 통해 공간을 실행할 때 얻는 것입니다), 32를 추가하는 루프 모든 캐릭터에게 171 개의 셀에 32를 더하기 위해 길을 벗어납니다. 여기에는 4 바이트의 비용이 들지만, 총 3 바이트를 절약하기 위해 나중에 139를 빼는 대신 171을 뺄 수 있습니다.

의견 :

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
>[.>>]

정력, 23

/[aeiou]<cr>"xd0wndb0Pw"xP

vim이 실제로이 도전에서 경쟁력이 있는지 궁금합니다. 아마도 골프 언어는 아니지만 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

파이썬, 68 63 60 바이트

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

Ideone에서 온라인으로 사용해보십시오 .

작동 원리

패턴 문자열이 3 번 반복 *3되어 패턴이 생성됩니다.

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

모든 인스턴스는 비어 있지 않은 모음이 아닌 빈 문자열이나 비어 있지 않은 문자열 다음에 단일 공백 ​​문자와 일치합니다.

첫 번째 인스턴스는 첫 단어가 시작될 때 자음과 일치합니다. +탐욕 스러우 므로 가능한 한 많은 수, 즉 첫 모음까지 일치 시키려고 시도합니다.

이 때문에 두 번째 인스턴스는 모음에서 시작하므로 단어를 구분하는 공간까지 포함하여 첫 번째 단어의 나머지 부분과 일치합니다.

첫 번째 인스턴스와 마찬가지로, 세 번째 단어는 두 번째 단어의 시작 부분에있는 모든 자음과 일치하므로 전체 패턴에 성공적으로 일치합니다.

원시 문자열 \3\2\1( rPython \3등을 제어 문자로 대체하지 못하게 함 )은 괄호로 묶은 패턴의 일치 순서를 반대로합니다. 즉, 두 번째 단어 의 시작 부분에서 자음으로 바꾼 다음 첫 번째 모음의 모든 문자 첫 단어는 우주까지, 마지막 단어는 첫 단어의 시작 부분에 있습니다.

sub( 1)에 대한 마지막 인수 는 첫 번째 교체 성공 후 즉시 반환되어 나머지 두 번째 단어에서 무의미한 교체를 피합니다. 패턴은 세 개 이상의 연속 자음 문자열과 일치 할 수 있기 때문에 필요합니다.

자바 스크립트 (ES6), 54 바이트

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

설명

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
  )

테스트

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>

파이썬 (3), 108 (101) 99 바이트

(정규식 사용 안함)

이 함수는 2 개의 인수를 통한 입력을 예상합니다 f('blushing','crow'). 새로운 단어를 튜플로 반환합니다.

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

많은 정규식 솔루션이 있으므로 Python의 re 라이브러리를 사용하지 않는 것을 작성하고 싶었습니다.

작동 원리

복잡한 부분은 람다 표현 S(약칭은 " 첫 번째 모음 앞에 S plit "을 의미 함 )입니다. 주어진 단어에 대해 재귀 적으로 "반복"하여 한 번에 한 단어 씩 s(전체 단어로 시작)부터 끝 p(비어 있음)으로 이동합니다. 첫 번째 모음 (p,s)에서 마침표 (접두사, 접미사)를 반환합니다 . 이는 매개 변수와 비교할 때 잘못된 순서입니다.

반환 된 순서가 접두사이고 접미사 인 것이 더 합리적이라고 생각했습니다 (일반적으로 접두사가 접두사 앞에 있기 때문에). 이 순서는 a,b=S(x)코드를 약간 더 읽기 쉽게 만들 수 있습니다 .

그러나 람다의 매개 변수에서 순서를 선택할 수 없었으므로 p전에 정의 할 수 없었습니다 s. 첫 번째 매개 변수는 s, 가지고 있기 때문에 전체 말을하는 p기본값을했고, 기본 매개 변수가 마지막으로 이동합니다. 그렇게하면 S빈 문자열로 함수 를 두 번 호출 할 필요가 없으며 몇 바이트를 저장할 수 있습니다. 그러나 람다 식에서 사용 된 접두사 / 접미사를 반대 순서로 반환하는 것은 잘못된 결정일 수 있습니다.

함수보다 람다 식을 선택하는 것 def S(s,p=""):return보다 말하기에 더 많은 바이트 가 필요 S=lambda s,p="":합니다. 파이썬에는 단락 평가와 삼항 연산자가 있기 때문에 선택을 할 수 있습니다. 그러나 나는 단락을 어떻게 사용했는지 충분히 설명 할 수 없다. 추론하기 어렵다.

이것이 나의 첫 대답입니다. 이 작업을 올바르게 수행하고 이길 수없는 솔루션을 게시하는 것이 가치가 있기를 바랍니다.

편집 : 고마워 주석가 : 바이트 수를 조금, 두 배로 줄이고 불필요한 정보를 제거했습니다. 쓰기 향상을 시도했습니다. 희망적으로 실수하지 않았다.

C # 6, 115 바이트

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

정규식의 네임 스페이스가 너무 길면 고통 스럽습니다.

CJam, 27 24 22 바이트

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

I / O는 한 줄에 한 단어입니다. 온라인으로 사용해보십시오!

작동 원리

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.

펄, 33 바이트

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

위의 코드는 32 바이트 길이이며 -p스위치 ( +1 바이트 ) 가 필요합니다 .

대체는 @DigitalTrauma의 Retina 답변 과 매우 유사 하지만이 답변은 PCRE의 재귀 하위 패턴을 활용 합니다.

Ideone에서 온라인으로 사용해보십시오 .

망막 , 34

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

온라인으로 사용해보십시오.

자바 스크립트 ES6, 93 58 52 바이트

ETHProductions 덕분에 6 바이트 절약!

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

그것을 테스트하십시오! (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 바이트

나는 여기에 많은 C 답변을 보지 못하므로 즐기십시오. 또한 처음으로 골프, 제안 및 비평을 환영합니다.

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

main ()이 필요하지 않은 경우 24 바이트를 절약하여 179 바이트를 얻을 수 있습니다.

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

언 골프 드 :

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

편집 : feersum의 제안 덕분에 54 바이트를 절약했습니다. = D

파이썬 2 364 352 269 251 바이트

편집 : 83 바이트 골프를 도와 주셔서 @Cyoce에게 대단히 감사합니다!

이 골프를 도와주세요! 어쨌든, 나는 적어도 첫 번째 파이썬 응답자입니다. Java 답변이 있으면 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)

여기 사용해보십시오

apt, 26 25 바이트

다행히도 며칠 전에 Japt의 정규 표현식 기능에 모음 클래스를 추가했습니다. 불행히도, 나는 모음이 아닌 클래스 또는 정규식 문자열의 이중 백 슬래시 주위에 방법을 추가하지 않았습니다.

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

은 ¿원시 문자의 U + 0093이어야한다. 입력은 한 줄로 된 여러 줄 문자열입니다. 온라인으로 사용해보십시오!

편집 : 이제 모음이 아닌 클래스 \V와 \\( %) 주위에 방법을 추가 했으므로이 코드는 이제 21 바이트에서 작동 합니다 . ( 온라인 시도 )

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

작동 원리

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

이전 버전 (26 바이트) :

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

온라인으로 사용해보십시오!

작동 원리

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

파이썬 3, 100 (또는 99) 바이트

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

몇 가지 버전으로 플레이했지만 아래에서 얻을 수없는 것 같습니다. def f(g)대신 사용하여 99 바이트를 줄일 수 있으므로 두 개의 별도 문자열 대신 문자열 목록이 필요하지만 두 개의 arg roue를 선호합니다.

대안은 길이가 같습니다.

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

@TanMath가 사용하는 것처럼 교체를 시도했지만 더 짧게 얻을 수 없었습니다. 또한 TanMath는 단일 인스턴스 만 일치하면되기 때문에 "[aeiou]"대신 사용하여 바이트 단위로 답을 더 짧게 얻을 수 있습니다 "[aeiou]+". 마지막으로, 구현은 input()py2와 py3 사이에서 변경된 것으로 보입니다-stdin을 문자열로 자동 평가합니다.

sed, 38 자

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

Retina 솔루션 의 확장 정규식 사용 .

위의 길이는 37 자이며 -r스위치 (+1 자) 가 필요합니다 .

예:

$ 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 바이트

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

넓히는:

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 자 / 42 바이트

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

Try it here (Firefox only).

이를 이해하는 데 도움이 필요하면 다음과 같이 ES6으로 변환됩니다.

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

PowerShell, 52 바이트

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

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

4 개의 캡처 그룹으로 대체 된 정규식입니다. 와:

• 확장 할 문자열 곱셈 :
  • ('(.*?)([aeiou]\S+) '*2) 에 '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
• "$args "정규식에 후행 공백이 그것을 파괴하지 않도록 강제로 인수의 문자열로 배열하고, 후행 공간을 추가합니다.

자바 스크립트 (ES6) 120 107 102 101 99 92 바이트

• 다운 다운 감사합니다!

매개 변수가 이와 같은 객체인지 여부를 고려합니다.
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)}

파이썬 129 108 105 109 바이트

이 프로그램은 다음과 같은 단어 목록을받습니다. ["master","plan"]

편집 : 감사 @Volatility

편집 : 이제 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)

이 답변은 대부분의 정규 표현식을 사용합니다.

여기 사용해보십시오

자바 8, 343 바이트

여기에 첫 번째 Java-Answer가 있습니다. 골프를 경험 한 사람은 아니므로 모든 제안에 감사드립니다!

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

언 골프 드 :

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

옥타브, 96 바이트

옥타브의 인라인 할당과 '인덱스 애니웨어'기능 덕분에이 모든 것은 단일 익명 함수의 정의 일뿐입니다. 의 컷 - 오프 포인트를 저장하는 동안 기본적으로, 우리는 spoonerized 문자열을 재구성 a하고 b. f컷오프 지점을 찾아서 ' find(ismember(a,b),1)' 전체를 두 번 사용하지 못하게 하는 인라인 함수에 특히 만족합니다 . 또한 정규 표현식이 없습니다 :) .

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

티 스크립트 , 27 바이트

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

\w실제로 [^aeiou]입니다.

엘릭서 ,143 117 바이트

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]

첫 번째 모음에서 두 줄 (a, b)을 분할하고 반환 할 새 줄을 구성합니다.

편집 : elem튜플에서 값을 가져 오기 위해 교묘 한 호출 대신 패턴 일치를 사용하여 몇 바이트를 벗어 났습니다.

자바, 147 바이트

나는 단지 기능도 좋다고 가정합니다.

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)불행히도 구분 기호를 사용 substring하므로 접미사를 가져와야합니다.

Pyth, 30 28 바이트

입력을 받아 두 단어의 목록으로 출력합니다.

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

온라인으로 사용해보십시오.

파이썬 (정규식 없음), 85 바이트

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

샘플 실행 :

>>> 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인수의 첫 번째 문자 다음에 가장 빠른 모음의 색인을 계산하는 재귀 함수입니다 s. 두 번째 문자가있는 경우 s[1]모음이고, 이는 평가 True갖고, int값 1. 그렇지 않으면 첫 번째 문자를 제거한 상태에서 재귀 호출을 수행하고 결과 색인에 1을 추가합니다 -~(2의 보수 보수). 마지막으로, 결과 t는 숟가락을 계산하기 위해 문자열 슬라이싱에 대한 인덱스로 사용됩니다.

GNU Awk 4.0, 48 자

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

샘플 실행 :

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 바이트

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

정규식을 사용하여 각 단어의 첫 글자가 아닌 문자를 바꿉니다.