Spoonerise单词

50

给定两个词，通过切换其初始辅音簇来对其进行轻描淡写。最少的字节数获胜。

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。

输出：以正确的顺序排列两根尖头的琴弦。

对于输入和/或输出，两个字符串也可以在列表等中，或者作为带有分隔符的单个字符串。

显示代码段

这是这个旧问题的近乎重复，但我希望编写一个更清晰，更稳定的规范，以便可以将旧问题作为重复对象关闭。

code-golf  string 
— 异或
source
4
单词以辅音开头。
— xnor
21
答案应该是"oozing snotter"IMO〜
— 帕特里克·罗伯茨
3
@PatrickRoberts我同意，但这会使挑战变得简单一些。
— xnor
1
主题不是很明显，但雪花的
— 瑕疵
1
快速的小马和co子不允许参加
— Denham Coote

Answers:

50

Vim，18击键

/[aeiou]<CR>dbwvnhp0P

关键技巧是在可视模式下粘贴内容实际上会将可视选择的旧内容放入粘贴缓冲区。

— 奥尔普
source
...哦，du，没想到。保持v包容性并尝试从元音中选择回去，以免被淘汰。
— Doorknob
10
作为vim的临时用户，每次键入连续的命令时，我都感到非常惊讶
— Aaron
4
<CR>表示回车（旧打字机术语！），也称为Enter
— Kai Carver
22

Brainfuck，238207字节

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

需要,在EOF，8位换行单元和从单元0向左移动的能力上返回0。以我的经验，这是最常见的默认设置。

我对此很满意。我的第一次尝试是314个字节，这肯定是一个改进。:)

它通过将输入中的每个字节存储在两个单元格中来工作；给定一个字节的实际值，另一个给出以下代码的输出（字节的值-97）：

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

如果字符是辅音，则该字符带有非零值。如果是元音，则变为0。从那里开始，只需查找第二个单词的起始位置并按顺序打印所有内容即可。

该程序的238字节版本在收集所有输入后找到了空格字符。这很令人头疼，因为这样做涉及在我要遍历的地方创建一个包含0的单元格。我解决的方法的效果是，第一个单词的每个字符减去30，之后的每个字符减去32。相当一部分代码专用于处理这种废话。

现在，从输入循环中的每个字符中减去32 ，该字符更短并且具有类似的副作用，更易于处理。另外，以这种方式进行操作使我可以用更短的方式创建自己的空间角色：与其从171中减去139（通过上方的元音检测器运行空间时得到的是171），而是添加了32的循环每个字符都尽力向171单元格添加32。这在那里花费了四个字节，但意味着我以后可以从中减去171（而不是减去139），从而总共节省了3个字节。

有评论：

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
>[.>>]
— 地下单轨铁路
source
这算作y元音，但问题是事实并非如此。（nye cat-> ce nyat）
— Loovjo，2016年
1
@Loovjo真的很奇怪，因为检查元音的代码肯定会y视为辅音...我将研究为什么这样做。
— undergroundmonorail
17

vim，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
— 门把手
source
11
我是在插入模式下执行的，对不对？
— Alex A.
5
@AlexA。ಠ_ಠ
— 门把手
@AlexA。插入模式将是一个额外的按键：）
— 〜– pydsigner
@AlexA。插入模式？您是说插入命令吗？
— Blacklight Shining
1
@BlacklightShining Nope。这是一个笑话，因为如果您处于插入模式并键入该内容，它将不会执行任何命令；您将刚刚在文件中键入它。
— Alex A.
13

Python，68 63 60字节

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

在Ideone上在线尝试。

这个怎么运作

模式字符串重复三次（*3），得到模式

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

所有实例将与非元音的非空字符串匹配，或者与后跟单个空格字符的非空字符串匹配。

第一个实例将匹配第一个单词开头的辅音。由于+是贪婪的，它会尝试匹配尽可能多的匹配，即全部匹配到第一个元音。

因此，第二个实例将从元音开始，因此它将匹配第一个单词的其余部分，直到并包括分隔单词的空间。

与第一个实例类似，第三个实例将在第二个单词的开头匹配所有辅音，从而成功匹配整个模式。

原始字符串\3\2\1（r防止Python \3用控制字符替换等）颠倒括号模式的匹配顺序，即，在第二个单词的开头用辅音替换它们，然后在第一个元音中替换所有字符直到空间的第一个单词，最后是第一个单词开头的辅音。

sub（1）的最后一个参数使它在第一次成功替换后立即返回，以避免在第二个单词的其余部分进行无意义的替换。这是必需的，因为该模式可以匹配三个或更多连续辅音的任何字符串。

— 丹尼斯
source
1
恭喜您，它以高效的regex将regex魔术带入了Python。很好的解释。
— xnor
11

JavaScript（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>
展开摘要

— 用户名
source
哦，我的坏，我误会了。我将在match回家时查看一下mdn文档
— Patrick Roberts
该+!i技巧是一个很好的解决方案。+1
— ETHproductions
10

Python 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库的东西。

这个怎么运作

唯一复杂的部分是lambda表达式S（缩写表示“ 第一个元音之前的S plit”）。它以递归的方式“迭代”给定的单词，一次将一个字符从s（从整个单词开始）的开头（到p从空开始）的结尾移动一个字符。在遇到的第一个元音中，它返回(p,s)，即（前缀，后缀）。请注意，与参数相比，这是错误的顺序！

我认为将返回的顺序先加上前缀再加上后缀（因为前缀通常在后缀之前）更有意义。此顺序可能会使a,b=S(x)代码更易于阅读。

但是我无法选择lambda的参数顺序，因此p之前无法定义s。第一个参数s，不得不把整个单词，因为p有一个默认值，默认参数走过去。这样做，我不需要S用空字符串两次调用该函数，因此可以节省一些字节。但是，以与在lambda表达式中使用的相反顺序返回前缀/后缀，可能只是一个错误的决定。

至于Lambda表达式而不是函数的选择，要说的字节def S(s,p=""):return多于S=lambda s,p="":。我之所以可以选择，是因为Python具有短路评估功能，并且具有三元运算符。但是，我无法充分说明我是如何使用短路的。很难推理。

这是我的第一个答案。我希望我正确地做到了这一点，并且发布无法成功的解决方案很有价值。

编辑： 谢谢评论者：减少了字节计数两次，并删除了不必要的信息。尝试改善写作。希望没有任何错误。

— N·贝里奇
source
欢迎来到ppcg，一个不错的第一答案:)仅供参考，该网站上的大多数程序都没有尾随换行符，因此您不必提及它（在极少数情况下有必要，那就是人们提到它的时候）
— undergroundmonorail
3
欢迎来到编程难题和代码高尔夫球！1.您不必担心输入格式。挑战明确表明您可以列出一个清单。2.根据标签Wiki中提到的默认值，您可以提交完整的程序或功能来编写高尔夫挑战赛代码。对于此特定问题，函数应短7个字节。
— 丹尼斯
4
关于最后一句话，“我希望发布无法取胜的解决方案是有价值的。” 最肯定的是！我们都在这里玩得开心，互相贡献，互相学习。我发现这个答案特别聪明，因为更明显的解决方案是使用正则表达式。非常好！
— Alex A.
一个很好的第一答案。这与我为非正则表达式想到的非常相似。您对使用短路逻辑表达式有很好的想法，事实证明它们可以缩短表达式，尽管您可能想考虑一下如何做到这一点。
— xnor
我真的很喜欢您使用递归解决方案的事实。实现得非常优雅！
— Ogaday
9

C＃6，115字节

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

正则表达式的名称空间太长了，真是太痛苦了。

— 手工电子食品
source
2
我的天哪，很冗长。
— 科纳·奥布莱恩
4
System.Text.RegularExpressions.Regex.Replace44个字符！+1，因为那一定是某种记录。
— 级圣河
2
...现在您有44个问题。;）
— 梅森·惠勒
9

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.
— 丹尼斯
source
8

的JavaScript ES6，93个 58 52字节

感谢ETHProductions，节省了6个字节！

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

测试一下！（仅限ES6）

显示代码段

— 科纳·奥布莱恩
source
当您进行此编辑时，我将要在我的58字节解决方案上单击发布答案哈哈
— user81655 2016年
@ user81655哦，很抱歉发生这种情况。
— Conor O'Brien
您完全不需要第四捕获组$4；）
— ETHproductions 2016年
@ETHproductions哦，是的！谢谢！
— 科纳·奥布莱恩
7

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

— 连塞·阿萨西诺（Lince Assassino）
source
我建议您调查一下strpbrk。
— feersum
+1这是一个很好的第一答案。欢迎来到该网站。
— wizzwizz4 2016年
感谢您的推荐@feersum。并感谢您的@ wizzwizz4欢迎！
— Lince Assassino
6

Python 2中，364个 352 269 251字节

编辑：非常感谢@Cyoce帮助我打高尔夫球了83个字节！

请帮我打高尔夫球！无论如何，至少我是第一个Python回答者。如果有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)

在这里尝试

— 棕褐色
source
5
-1表示不尝试在单字符变量之外进行打高尔夫
— Mego
@Mego我保证我会尽快进行这项工作。马上。但是我正在开发一个正则表达式版本。
— TanMath
@Mego，请参阅编辑。
— TanMath
5

Japt，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
— ETH生产
source
我希望主流语言有一个用于正则表达式的元音元！
— CJ Dennis
4

Python 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评估为字符串。

— 大贺天
source
1
想必您是说s=re.split替代方案？
— xnor
是! 绝对是 这是我第一次打高尔夫球，因此感谢您提供任何反馈和建议。
— Ogaday
1
1.该问题明确允许将两个字符串作为列表，因此*in 似乎没有充分的理由*g。2.第二个版本可以打到lambda x,y,s=lambda s:re.split("[aeiou]",s)[0]:(s(y)+x[len(s(x)):],s(x)+y[len(s(y)):])。
— 丹尼斯
感谢@Dennis，它确实可以正常工作，很好的重构。有趣的是，需要使用方括号，并且您不需要将s作为arg传递给第二个lambda吗？该解决方案为我提供了98个字节，并带有前导import语句和f=。
— Ogaday
1
不，s它是默认参数，因此您不必指定它。未命名的lambda是可以接受的提交；f=不需要。
— 丹尼斯
4

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
— 佐尔特
source
欢迎来到编程难题和代码高尔夫球！
— 丹尼斯
3

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());
— 手工电子食品
source
这已经很老了，但是"aeiou".ToCharArray()可以是'a','e','i','o','u'-2个字节
— 无知的体现
不，@EmbodimentofIgnorance，IndexOfAny它不需要参数，所以它必须是new[]{'a','e','i','o','u'}
— Hand-E-Food
啊，我的错误，我认为这IndexOfAny是一种参数方法。无论如何，好的答案
— 无知的体现
3

𝔼𝕊𝕄𝕚𝕟，24个字符/ 42个字节

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

Try it here (Firefox only).

如果您需要帮助，请理解为ES6 

input.replace(/([^aeiou]+)(.+ )([^aeiou]+)/g,'$3$2$1')
— 妈妈趣味卷
source
这是什么语言？我什至得到了盒子字符。
— 杰西·威廉姆斯
@JesseWilliams叫做ESMin。
— ETHproductions 2016年
如果插入器具有类似于Japt的东西，它将向您显示js变成js，那就太好了
— 通用用户
运行代码时，已编译的JS将记录在JS控制台中。
— Mama Fun Roll
3

PowerShell，52个字节

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

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

它是用四个捕获组替换的正则表达式；与：

  • 字符串乘法扩展：
    • ('(.*?)([aeiou]\S+) '*2) 至 '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
  • 将"$args "args数组强制为字符串，并添加尾随空格，以便正则表达式中的尾随空格不会破坏它。
— TessellatingHeckler
source
3

的JavaScript（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)}
— 鹅毛笔
source
.match(/[aeiou]/).index可以成为：.search`[aeiou]`
— Downgoat
3

Python中，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)

这个答案使用正则表达式，就像大多数人一样。

在这里尝试

— 棕褐色
source
请注意，它将str.replace替换子字符串的所有实例，因此，您需要使用来将其限制为一次替换.replace(f,l,1)。但是，您可以使用i,j=input()，重新绑定re.findall和'[^aeiou]+'单个字符变量来节省一大堆。
— 波动率
这是行不通的。即使是两个单字母单词也会给您三个字符，并且您试图将其input()分解为两个变量。你是说i,j=input().split()（raw_input()在Python 2中）吗？
— Blacklight Shining
1
@BlacklightShining这个单词至少需要一个元音和一个辅音。输入采用字符串列表，因此i是第一个单词，j是第二个单词。
— TanMath
@TanMath据我知道，是默认允许的，但你应该在回答某个地方可能会说，它的要求
— undergroundmonorail
这取代了太多。"sass","bit" -> "babb", "sit"。
— xnor
3

Java 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));
    }
}
— 登克
source
什么java.util.function.Function啊 我非常怀疑它是否应该存在，除非您是故意的import，但是请删除该导入，因为您只引用了一次。更改public class C{public static void Main(String[] a)为interface C{void Main(String[]a)
— 猫
Function<String, Integer>不需要空白
— 猫
改变for循环从for(int i=0;i<s.length();++i)if("aeiou".contains(s.substring(i,i+1)))return i;到for(int i=0;i++<s.length();if("aeiou".contains(s.substring(i,i+1))){return i;})
— 猫
i1是一个可怕的，太长的变量名。
— 猫
也就是说，改变Function<String, Integer>以java.util.function.Function<String,Integer>拖放进口
— 猫
3

八度，96字节

多亏了Octave的内联分配和“无处索引”功能，整个事情才仅仅是单个匿名函数的定义。基本上，我们在将截断点存储在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)];
— 桑切斯
source
2

TeaScript，27个字节

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

\w实际上是[^aeiou]。

— 下山羊
source
等等，您将默认\w正则表达式元更改为[^aeiou]？为什么？
— ETHproductions 2016年
创建自定义字符类时使用@ETHproductions。我忘\w了JavaScript已经使用过了。我会尽快将其改回
— Downgoat
2

药剂，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调用来获取元组中的值，从而节省了一些字节。

— 斯雷尼希
source
2

Java，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来获取后缀。

— 精英
source
2

Pyth，30 28字节

接受输入并以两个单词的列表形式给出输出。

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

在线尝试。

— 路加
source
我认为您正在寻找ACm,Kh:d"[aeiou]"3.-dKQ+V_GH。A将两个元素的列表分配给G和H，然后进行C转置。可能会有更好的东西。
— lirtosiast '16
2

Python（无正则表达式），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值为value 1。否则，它将进行递归调用，并删除第一个字符，然后使用-~（一个人的补码的两个补码）在结果索引中加1。最后，将的结果t用作字符串切片的索引，以计算竖向性。

— 安德斯·卡塞格（Anders Kaseorg）
source
1

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
— 工作的人
source
1

PowerShell，61字节

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

使用正则表达式交换每个单词的前一个非元音字符

— Mathias R. Jessen
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.