从babbab到zyzyz的每个词

38

您的任务是编写一个程序，该程序将输出具有以下结构的每五个字母单词的可读列表：

辅音-元音-辅音-元音

输出应按字母顺序排序，每行一个单词，并且没有重复的单词两次。可以是小写或大写，但不能混合使用。因此，列表可以像这样开始和结束：

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz

元音是一个 - ë - 我 - Ø - ü - Ÿ，其他20个英文字母都是辅音字母。
单词不一定是实际的词典单词。
最短的代码胜出。

注意：几年前，我在大学网站上偶然发现了一个完全符合此要求的程序。原来我的名字和姓氏符合cvcvc约束，我一直在自我搜索。

code-golf  string  kolmogorov-complexity  combinatorics 
— 威尔克斯
source
7
我在这里看到两件事。首先，有很多这样的单词。您希望如何测试这些条目？另外，有许多适合该约束的名称。首先想到的是雅各布（Jacob），尽管卢卡斯（Lucas）等其他人也很合适
— TrojanByAccident
9
@TrojanByAccident我相信，挑战需要所有可能匹配的字母组合，无论它们是名称/英文单词。“单词不必是实际的词典单词。”
— trichoplax
3
@wilks 相关的元发布 -严格的I / O格式在此SE社区中不受欢迎。这个挑战集中在生成cvcvc单词上，而不是在单词之间插入换行符，不是吗？
— JungHwan Min
1
@JungHwanMin感谢您的链接，这是我第一次来，对此我一无所知。我将其视为所有cvcvc单词的可读性和字母顺序的列表。因此，我同意大写或小写字母确实无关紧要，但是我也认为，一个非常长的字符串，或者说是一些嵌套数组，虽然在技术上有效，但这并不是一个很好的答案。
— 威尔克斯
2
在回答了这个问题的一些建议后，他们显然不符合“输出应该是递增的，每个单词在自己的行上”。是否放宽了此要求，如果可以，您是否可以编辑问题以反映这一点？我认为如果答案不受格式的限制，我可能会丢失很多字节。
— ElPedro

Answers:

28

Mathematica，72 65 61字节

Print@@@Tuples@{a=##/(b=#5#9#15#21#25#)&@@Alphabet[],b,a,b,a}

为了测试，我建议更换Print@@@用""<>#&/@。然后，Mathematica将显示一个截断的表格，显示前几个单词和最后几个单词，而不是永远花费288,000行。

说明

我终于找到了分割字符串的用途。:)

一段时间内添加或乘法字符串的可能性使我很感兴趣，但是实际用例非常有限。要点是，类似"foo"+"bar"或的东西"foo"*"bar"（因此简称为"foo""bar"）在Mathematica中是完全有效的。但是，它并不真正知道如何处理算术表达式中的字符串，因此这些事情仍未得到评估。尽管Mathematica 确实适用于普遍适用的简化。特别是，字符串将按规范顺序排序（一旦开始对包含各种大小写字母，数字和非字母的字符串进行排序，在Mathematica中就相当混乱了），这通常是一个大问题，但在这里并不重要。此外，"abc""abc"将简化为"abc"^2（当您重复字符串时，这是一个问题，但是我们也没有），并且类似的东西"abc"/"abc"实际上会取消（我们甚至会利用它）。

那么我们要在这里打高尔夫吗？我们需要一个元音列表和辅音列表，因此我们可以提供它们Tuples以生成所有可能的组合。我的第一种方法是幼稚的解决方案：

Characters@{a="bcdfghjklmnpqrstvwxz",b="aeiouy",a,b,a}

硬编码的辅音列表确实有点痛。Mathematica确实具有Alphabet内置功能，如果我能够以便宜的方式删除元音，则可以避免使用。这是棘手的地方。删除元素的最简单方法是Complement，但是使用以下选项之一，最终会变得更长：

{a=Complement[Alphabet[],b=Characters@"aeiouy"],b,a,b,a}
{a=Complement[x=Alphabet[],b=x[[{1,5,9,15,21,25}]]],b,a,b,a}

（请注意Characters，由于Alphabet[]给出的是字母列表，而不是字符串，因此我们不再需要将其应用于整个内容。）

因此，让我们尝试一下算术业务。如果我们将整个字母表示为字母的乘积而不是列表，那么由于取消规则，我们可以通过简单的除法来删除字母。这样可以节省很多字节，因为我们不需要Complement。此外，"a""e""i""o""u""y"实际上比短一个字节Characters@"aeiouy"。因此，我们这样做：

a=##/(b="a""e""i""o""u""y")&@@Alphabet[]

我们分别在a和中存储辅音和元音产品的位置b。这是通过编写一个函数来实现的，该函数将其所有自变量与乘以##元音的乘积并相除。此功能适用于字母列表，该列表将每个字母作为单独的参数传递。

到目前为止一切顺利，但现在我们有了 

{a=##/(b="a""e""i""o""u""y")&@@Alphabet[],b,a,b,a}

作为的参数Tuples，这些东西仍然是产品，而不是列表。通常，最短的修复方法是将a List@@@放在最前面，这会将产品再次变成列表。不幸的是，添加这7个字节使其比幼稚的方法更长。

但是，事实证明，Tuples根本不关心内部列表的开头。如果你这样做

Tuples[{f[1, 2], f[3, 4]}]

（是的，对于未定义f。）您将获得：

{{1, 3}, {1, 4}, {2, 3}, {2, 4}}

就像您使用List而不是一样f。因此，我们实际上可以直接将这些产品传递给您，Tuples并仍然获得正确的结果。与使用两个硬编码字符串的天真的方法相比，这节省了5个字节。

现在"a""e""i""o""u""y"仍然相当烦人。但是，等等，我们也可以在此处保存一些字节！我们函数的参数是单个字母。因此，如果我们只选择正确的参数，则可以重用这些参数，而不是使用字符串常量，因为三个字符串都较短。我们要争论#（简称#1）#5，#9，#15，#21和#25。如果放在#最后，那么我们也不需要添加任何东西*来将它们相乘，因为（regex）#\d+是一个完整的令牌，不能附加任何非数字。因此，我们最后得到#5#9#15#21#25#，又节省了4个字节。

— 马丁·恩德
source
11
阅读说明。所以...基本上是魔术。
— Tally
你的Tuples把戏让我感到惊讶和印象深刻。那是完全没有证件的，对吧？考虑到两输入形式如何Tuples[list,n]处理list没有List头部的问题（至少对我而言）！
— 西蒙斯（Simmons），
— ngenisis
1
@ngenisis我觉得措辞很混乱。因为不清楚在使用多个列表时这是否指向外部列表。确实Tuples[f[{1,2}, {3,4}]]给了{f[1, 3], f[1, 4], f[2, 3], f[2, 4]}。没有记录表明内头被完全忽略了。
— Martin Ender
@ASimmons抄送 ^
— Martin Ender
16

Perl，47个字节

#!perl -l
/((^|[aeiouy])[^aeiouy]){3}/&&print for a..1x5

把shebang算作一个。

在线尝试！

— 原始
source
2
很好，做得好！有什么原因不使用say？
— Dada
谢谢。我不同意这-M5.01应该是“自由”。
— primo
1
我喜欢你的看法-M5.010。而且高尔夫中的有趣部分不能替换print为say……
— Dada
是不是-E（然后是say）免费赠品？
— Zaid
@Zaid See Primo的第一则评论
— Dada
11

Python 3-110个字节

a,b="bcdfghjklmnpqrstvwxz","aeiouy";print(*(c+d+e+f+g for c in a for d in b for e in a for f in b for g in a))

直接循环的乐趣:)

— 卡拉
source
认为我们的想法是相同的，但是您使用Python 3击败了我10分！
— ElPedro
我正打算使用这种方法发布一个等效的python2。太慢了，改为为您投票。
— 克里斯·H
8

Ruby，72 71 52字节

puts (?z..?z*5).grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/

感谢Value Ink提供了基本概念，将其缩减为60个字节。

— 国标
source
1
生成5个字母的单词列表并使用会更短grep。如果生成使用小写字符串的范围，则只会得到一系列小写单词。puts ("babab".."zyzyz").grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/60字节
— Value Ink 2013年
7

05AB1E，18 16字节

05AB1E使用CP-1252编码。

žP3ãžO3ãâ€øJ€¨ê»

说明

žP3ã                # push all combinations of 3 consonants
    žO3ã            # push all combinations of 3 vowels
        â           # cartesian product
         €ø         # zip each pair of [ccc,vvv] (c=consonant,v=vowel)
           J        # join to list of strings ['cvcvcv','cvcvcv' ...]
            ۬      # remove last vowel from each
              ê     # sort and remove duplicates
              »     # join on newlines

为了进行测试，我建议用žP一些辅音和žO一些元音代替。

使用5个辅音和3个元音的示例

— 艾米尼亚
source
很好地使用笛卡尔积。不会想到的。
— Magic Octopus Urn
7

纯净重击，74

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval echo $c$v$c$v$c

直截了当的括号扩展。

在线尝试。

如果每个项目必须在自己的行上，则我们有：

纯净重击，84

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval printf '%s\\n' $c$v$c$v$c
— 数字创伤
source
7

PHP，88 86 84 80字节

漂亮的字符串增量:)
@Christoph保存了6个字节

for($s=$v=aeiouy;++$s<zyzza;preg_match("#[^$v]([$v][^$v]){2}#",$s)&&print"$s
");

循环遍历从bababa到的所有字符串，zyzyz并测试它们是否匹配模式。用运行-nr。

— 提图斯
source
大声笑，打高尔夫球的语言规范，我喜欢
— Patrick Roberts
1
@PatrickRoberts这不是一个错误。这是一个功能。：DI很遗憾，他们将隐式转换嵌入到$a="001";$a++;某天。这是非常不方便的更改。
— 泰特斯
1
for($s=$v=aeiouy;++$s<zyzza;)preg_match("#[^$v][$v][^$v][$v][^$v]#",$s)&&print"$s\n";为您节省1个字符。可悲的是，您必须更改echo才能使用&&。替换\n为实际的换行符可以节省另一个。
— 克里斯多夫（Christoph）
1
您可能会使用保存一些字符，"#([^$v][$v]){2}​[^$v]#"但我尚未对其进行测试。
— 克里斯多夫（Christoph）
1
@Christoph：知道为什么，但是([^$v][$v]​){2}[^$v]在循环中[^$v]([$v]​[^$v]){2}不起作用。两者都可以独立工作（即使使用变量也可以）。
— 泰特斯（Titus），
6

MATL，21字节

11Y2'y'h2Y2X~6Myyy&Z*

在线尝试！（但输出被截断）。

11Y2   % Push 'aeiou' (predefined literal)
'y'    % Push 'y'
h      % Concatenate: gives 'aeiouy'
2Y2    % Push 'abcdefghijklmnopqrstuvwxyz' (predefined literal)
X~     % Set symmetric difference: gives 'bcdfghjklmnpqrstvwxz'
6M     % Push 'aeiouy' again
yyy    % Duplicate the second-top element three times onto the top. The stack now
       % contains 'bcdfghjklmnpqrstvwxz', 'aeiouy', 'bcdfghjklmnpqrstvwxz',
       % 'aeiouy', 'bcdfghjklmnpqrstvwxz'
&Z*    % Cartesian product of all arrays present in the stack. Implicity display
— 路易斯·门多
source
我想，这应该工作，剃一个字节：11Y2'y'h2Y2yX~yyy&Z*（在线试试吧！）
— 康纳尔奥布莱恩
@ ConorO'Brien不幸的是，这会创建vcvcv模式，而不是cvcvc所需的。不过谢谢！
— Luis Mendo
6

Python，92个字节

f=lambda i=-4,s='':i*[s]or sum([f(i+1,s+c)for c in i%2*'AEIOUY'or'BCDFGHJKLMNPQRSTVWXZ'],[])

不能让itertools胜利。迭代在Python 2中长1个字节。

W='',
for s in(['AEIOUY','BCDFGHJKLMNPQRSTVWXZ']*3)[1:]:W=[w+c for w in W for c in s]
print W
— 异或
source
太棒了^ _ ^
— ABcDexter
6

Haskell，54 51字节

l="bcdfghjklmnpqrstvwxz":"aeiouy":l
mapM(l!!)[0..4]

mapM func list通过从返回的列表中获取索引i的可能字符来构建所有单词func (list!!i)。

编辑：@xnor发现2个字节要保存，并查看他的解决方案，我发现了另一个。

— 妮米
source
mapM id$take 5$cycle["bcdfghjklmnpqrstvwxz","aeiouy"]保存一个字节。
— xnor
更好的mapM(cycle["bcdfghjklmnpqrstvwxz","aeiouy"]!!)[0..4]还是mapM(["bcdfghjklmnpqrstvwxz","aeiouy"]!!)[0,1,0,1,0]。最好不要对元音和辅音进行硬编码，但mapM(\n->[x|x<-['a'..'z'],elem x"aeiou"==odd n])[0..4]并不能完全做到这一点。
— xnor
@xnor：谢谢！cycle用显式递归替换第一个变量可节省一个额外的字节。
— nimi
5

Brachylog，18个字节

@W:@Dg:2jcb:eac@w\

在线尝试！

说明

@W:@D                 The list ["aeiouy", "bcdfghjklmnpqrstvwxz"]
     g:2jcb           The list ["bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz"]
           :ea        Take one character of each string
              c       Concatenate into a single string
               @w     Write to STDOUT followed by a newline
                 \    Backtrack: try other characters of the string
— 致命
source
我对gand 的需要感到惊讶b，但是对它进行了测试，这是因为j似乎拒绝接受字符串列表作为输入吗？:ea确实展示了Prolog / Brachylog的优势，这是大多数其他语言所面临的困难。
@ ais523是的，我也感到惊讶，g并且b需要。j似乎是错误的，这又是由于难以将参数列表与仅列表区分开来。我可能会解决此问题，尽管这将再次使实现复杂化。我也可能不修复它，而是花时间解决新版本的Brachylog中的核心问题。
— Fatalize
5

JavaScript（ES6），91 90字节

f=(s='',i=4)=>{for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')i?f(s+c,i-1):console.log(s+c)}

编辑

  • ETHproductions：-1字节，通过删除for语句中三元运算符周围的无关组

说明

这定义了一个5深递归函数，该函数使用其调用深度的奇偶性来确定是迭代元音还是辅音。在每次迭代中，它通过检查剩余的递归数量来检查是否要递归或打印，并将其当前迭代的字母连接到当前深度优先构建的5个字符串的末尾。

假设ISO8859-1编码的替代89字节解决方案：

f=(s='',i=4)=>{for(c of i%2?'aeiouy':btoa`mÇ_äi骻-¿s`)i?f(s+c,i-1):console.log(s+c)}

替代的96字节解决方案，将整个输出作为单个字符串返回：

f=(s='',i=4,o='')=>eval("for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')o+=i?f(s+c,i-1):s+c+`\n`")

运行风险自负。对于91字节的解决方案，只需使用f()；对于97字节的替代方法，请使用console.log(f())。

— 帕特里克·罗伯茨
source
我尝试以两种不同的方式将解决方案转换为生成器。使用仅受Firefox支持的简写形式的长度是相同的：f=(s='',i=2)=>(for(c of(i%2?'aeiouy':'bcdfghjklmnpqrstvwxz'))for(q of i?f(s+c,i-1):[s+c])q)不幸的是，使用标准形式的长度要长一个字节：function*f(s='',i=2){for(c of(i%2?'aeiouy':'bcdfghjklmnpqrstvwxz'))yield*i?f(s+c,i-1):[s+c]}仍在等待生成器是最短选项的一天……
— ETHproductions'Jan 12''17
1
顺便说一句，您可以在for...of语句中删除内部括号以保存一个字节
— ETHproductions
5

C，201个 199 186 184 183 169 163字节

与以前的基本计数方法稍有不同：

f(){for(char*c="bcdfghjklmnpqrstvwxz",*v="aeiouy",i[5]={0},*s[]={c,v,c,v,c},j=0;j<5;puts("")){for(j=5;j--;putchar(s[j][i[j]]));for(;j++<5&&!s[j][++i[j]];i[j]=0);}}

取消高尔夫：

f() {
    for(char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[5]={0}, *s[]={c,v,c,v,c}, j=0; j<5; puts("")) {
        for (j=5; j--; putchar(s[j][i[j]])) ;
        for (; j++ < 5 && !s[j][++i[j]]; i[j]=0) ;
    }
}

并以更常规的方式编写：

f() {
    char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[]={0,0,0,0,0}, *s[]={c,v,c,v,c}, j=0;
    while (j>=0) {
        for (j=0; j<5; j++) putchar(s[j][i[j]]); // output the word
        while (--j>=0 && !s[j][++i[j]]) i[j]=0; // increment the counters
        puts("");
    }
}

基本上，我是计数器，而s是一个字符串数组，其中包含每个计数器要迭代的所有字符。诀窍是内部while循环：它用于从最右边的计数器开始递增计数器。如果看到应该显示的下一个字符是结尾的空字符，则将计数器重新启动为零，并且“进位”将传播到下一个计数器。

谢谢克里斯托夫！

— 暗淡
source
欢迎来到PPCG！
— 马丁·恩德
1
char *c我认为空间是不必要的。
— 克里斯多夫（Christoph）
1
f(){char*c="bcdfghjklmnpqrstvwxz",*v="aeiouy",i[]={0,0,0,0,0},*s[]={c,v,c,v,c},j=0;while(j>=0){for(j=0;j<5;++j)putchar(s[j][i[j]]);for(;--j>=0&&!s[j][++i[j]];)i[j]=0;puts("");}}使您达到177。加油，您可以做得更好;）。
— 克里斯多夫（Christoph）
2
使用i[5]={0}而不是i[]={0,0,0,0,0}保存7个字节。
— 法肯（Falken）
1
@Christoph Aha，谢谢。做得好。但是您似乎很喜欢它，这就是为什么我要挑战（不，我在开玩笑：我这样做是因为我很痛苦）。真的，谢谢您的启发。
— 暗淡
4

Perl，71个字节

map{push@{1+/[aeiouy]/},$_}a..z;$"=",";say for glob"{@1}{@2}"x2 ."{@1}"

在线尝试！

说明

稍后再添加更多说明。

map{push@{1+/[aeiouy]/},$_}a..z;创建两个数组：@1包含辅音，并@2包含元音。
glob当使用类似参数的调用时，{a,b}{c,d}返回括号中元素的所有排列。

— 达达
source
4

Befunge，95个字节

::45*%\45*/:6%\6/:45*%\45*/:6%\6/1g,2g,1g,2g,1g,55+,1+:"}0":**-!#@_
bcdfghjklmnpqrstvwxz
aeiouy

在线尝试！，尽管请注意输出将被截断。

这只是一个范围从0到287999的循环，将索引输出为混合的数字20-6-20-6-20，最后两行从表中检索数字的“数字”。

— 詹姆斯·霍尔德尼斯
source
4

Perl 6，70个字节

$_=<a e i o u y>;my \c=[grep .none,"a".."z"];.say for [X~] c,$_,c,$_,c

有趣的部分的解释：

.say for [X~] c, $_, c, $_, c

              c, $_, c, $_, c  # list of five lists
         [X ]                  # lazily generate their Cartesian product
           ~                   # and string-concatenate each result
.say for                       # iterate to print each result

之前的代码仅生成元音列表（$_）和辅音列表（c），这很冗长。

— 短信
source
4

Python 2中，120个 117字节

感谢@WheatWizard提供的标签提示。

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
for a in x:
 for e in x:
	for b in y:
		for c in y:
			for d in y:print b+a+c+e+d

在线尝试！

不确定是否可以打很多球。尝试在线截断128KB，但显示出足够的意思。使用调试代码对单词进行计数的本地运行总计提供288000个。如果有人要测试，则运行大约45秒。

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

不兼容且因此不具有竞争性的版本（打印出嵌套数组，而不是指定的格式）为110字节：

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
print[[[[c+a+d+b+e for e in y]for d in y]for c in y]for b in x]for a in x]
— 埃尔佩德罗
source
1
是我的第一个实现方法：）
— 卡拉（Carra）
代替为所有缩进使用空格，可以将空格用于单个缩进，将制表符用于双精度。
— 小麦巫师
4

Perl 6，53字节

/<-[aeiouy]>**3%<[aeiouy]>/&&.say for [...] <a z>Xx 5

需要一点时间才能有任何输出。效率很低。做这份工作。

— 疯子节俭珠宝
source
欢迎来到PPCG！
— Martin Ender
4

xeger，49个字节

([bcdfghj-np-tvwxz][aeiouy]){2}[bcdfghj-np-tvwxz]

给定一个正则表达式，xeger会简单地生成所有匹配的字符串。为了不破坏浏览器，它每1000个输出都会暂停一次，您需要单击以继续，但最终它将到达那里。

这是一个23字节的版本，其中包含一个已修复的错误^：

([:c^y][:v:y]){2}[:c^y]

这些字符类“所有小写ASCII辅音” [:c]与y排除^y，以及“所有小写ASCII母音” [:v:]与y添加。

— 迈克尔·荷马
source
这是基于什么正则表达式的？（或者，如果您自己发行，它支持什么功能？是否有任何文档？）
— Martin Ender
@MartinEnder这是DFA遍历的自带工具（从我为学生构建的DFA / NFA可视化工具中生长，该文档具有一些有限的文档）-没有反向引用，没有任何非常规引用。对于较长的字符串，这非常慢。表达式本身唯一有趣的功能是与&。
— 迈克尔·荷马”，
我在页面上添加了其余文档和一些示例。
— Michael Homer
1
看起来您已经在字符类中实现了范围。那你可以做[bcdfghj-np-tvwxz]。
— Martin Ender
4

JavaScript（Firefox 30-57），82个字节

f=(i=5)=>i?[for(s of f(i-1))for(c of i%2?'bcdfghjklmnpqrstvwxz':'aeiouy')s+c]:['']

返回字符串数组。102 101的非常快的版本（1个字节，感谢@ETHproductions）：

_=>[for(i of c='bcdfghjklmnpqrstvwxz')for(j of v='aeiouy')for(k of c)for(l of v)for(m of c)i+j+k+l+m]
— 尼尔
source
真好 有一个在快速版本的外来空间，可以为101个字节被删除
— ETHproductions
3

CJam，32 31 29 28字节

感谢Martin Ender，节省了2个字节；感谢kaine，节省了1个字节

"aeiouy"_'{,97>^\1$1$1$N]:m*

在线尝试！（请注意，输出在TIO上被切断）

说明

"aeiouy"_ e# Push the six vowels and duplicate
'{,97>    e# Push the whole alphabet
^         e# Symmetric set difference of the alphabet with the vowels, yields the consonants only
\         e# Swap top two elements
1$1$1$    e# Copy the second-from-the-top string to the top three times
          e# This results in the array being consonants-vowels-consonants-vowels-consonants
N         e# Add a newline character to the end of the list
]         e# End an array. Puts everything done so far in an array
          e# since there was no explicit start of the array.
:m*       e# Reduce the array using Cartesian products
— 商务猫
source
'{,97>得到字母。然后"aeiouy"_'{,97>^在上保存另一个字节1$。
— 马丁·恩德
您不需要第一个字符。假设它是否开始堆栈。
— kaine
@kaine有趣，不知道。谢谢。
— Business Cat
$“ aeiouy” _'{，97> ^] 3 *（;: m * N * $忽略$符号
— 。Idk
@kaine使用反引号，例如“`”。
— 科纳·奥布莱恩
3

Perl，63 59 54字节

$a="aeiouy";$b="[^$a][$a]"x2;for("a"x5.."z"x5){say if/$b[^$a]/}
$a="aeiouy";$b="[^$a][$a]"x2;/$b[^$a]/&&say for"a"x5.."z"x5

$a=aeiouy;$b="[^$a][$a]"x2;/$b[^$a]/&&say for a.."z"x5

尝试改变Perl高尔夫。
编辑：看来我还有很多要学习... :)

— 短信
source
不错的一个（即使Primo的答案更短）。您可以将结尾写为/$b[^$a]/&&say for"a"x5.."z"x5节省一些字节。编辑：您可以删除$b和做$a="aeiouy";/([^$a][$a]){2}[^$a]/&&say for"a"x5.."z"x5。
— 达达
此外，您也不需要使用引号aeiouy。另外，由于您的正则表达式检查5个字符，因此您可以执行a.."z"x5。
— 达达
@Dada：谢谢。作为使用Perl进行常规编程但直到现在为止都不打高尔夫球的人，我什至没有想到要使用非严格模式。这就是为什么我选择$a和$b作为变量名的原因，因为即使在严格模式下也不需要声明这些名称... :)这些天我也经常使用Perl 6，甚至没有非严格模式。
— smls
3

Scala，87 86字节

val a="aeiouy"
val b='a'to'z'diff a
for(c<-b;d<-a;e<-b;f<-a;g<-b)println(""+c+d+e+f+g)
— jaxad0127
source
您可以替换f"$c$d$e$f$g"使用""+c+d+e+f+g，以节省一个字节。
— corvus_192
3

R，143132字节

q=letters;v=c(1,5,9,15,21,25);x=list(q[-v],q[v],q[-v],q[v],q[-v]);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(sapply(x,length))))


q=letters;v=c(1,5,9,15,21,25);x=list(a<-q[-v],b<-q[v],a,b,a);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(lengths(x))))

这是我第一次参加代码高尔夫，所以我欢迎提出进一步建议的任何建议。到目前为止，所有这些都是标准R。唯一可能棘手的是，paste0将其参数循环到最长的参数的长度。

编辑：使用了rturnbull的分配技巧，替换sapply(x,length)为lengths。

— 帕特里克·B。
source
欢迎光临本站！看起来不错（我自己只在R中编程过一点），我建议不要在答案中包含旧代码。编辑历史记录始终可用，因此任何希望查看的人都可以随时查看。这更多是个人风格问题，请随时忽略我的意见。
— 小麦巫师
您可以通过114个字节的功能分配来强行使用它！
— Punintended
3

R，111 98字节

y感谢@Patrick B，将其添加为元音并打了13个字节。

l=letters
v=c(1,5,9,15,21,25)
apply(expand.grid(C<-l[-v],V<-l[v],C,V,C)[,5:1],1,cat,fill=T,sep="")

我们使用expand.grid生成矩阵中V和的所有可能组合，并C根据预设变量letters（字母）定义矩阵。我们反转组合（因为默认是第一个变量旋转最快），以确保字母顺序。然后，我们遍历矩阵的每一行，将每个字母打印到stdout。我们使用fill参数来cat确保每个单词都以新行开头。

— 土拨鼠
source
真好！您可以通过在cat中使用某些选项并重命名“字母”，将其进一步细分为98个字符（将“ y”作为元音添加，如果不是，则为95）：l = letters; v = c（1,5,9， 15,21,25）; apply（expand.grid（C <-l [-v]，V <-‌l [v]，C，V，C）[，5：1]，1，‌cat ，fill = T，sep =“”）
— Patrick B.
@帕特里克·B。谢谢！我已将您的建议纳入其中。
— rturnbull
— J.Doe
2

Clojure，101个字节

(print(apply str(for[V["aeiouy"]C["bcdfghjklmnpqrstvwxz"]a C b V c C d V e C](str a b c d e "\n")))))

没那么令人兴奋...

— 尼古妮
source
2

Ruby，65 61字节

完全不同的方法：

(b=[*?a..?z]-a="aeiouy".chars).product(a,b,a,b){|x|puts x*""}

我今天学到的新东西：Array＃product函数

— 国标
source
2

C 361字节

f(){i,j,k,l,m;v[6]={97,101,105,111,117,121};c[25];s=26;for(i=0;i<26;i++)c[i]=97+i;for(i=0;i<26;i++){for(j=0;j<6;j++)if(c[i]==v[j])c[i]+=1;}for(i=0;i<s;i++)for(j=i+1;j<s;){ if(c[i]==c[j]){for(k=j;k<s-1;++k)c[k]=c[k+1];--s;}else ++j;}for(i=0;i<s;i++)for(j=0;j<6;j++)for(k=0;k<s;k++)for(l=0;l<6;l++)for(m=0;m<s;m++)printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);}

非高尔夫版本：

void f()
{   
int i,j, k,l,m;
int s=26;
int v[6]={97,101,105,111,117,121};
int c[s];

for(i=0;i<s;i++)
 c[i]=97+i;
for(i=0;i<s;i++)
{     
  for(j=0;j<6;j++)
    if(c[i]==v[j])
      c[i]+=1;
     }
for(i=0;i<s;i++)
 for(j=i+1;j<s;)
 { if(c[i]==c[j])
  {
    for(k=j;k<s-1;++k)
      c[k]=c[k+1];
      --s;  
  }else
   ++j;  
  }
for(i=0;i<s;i++)
  for(j=0;j<6;j++)
       for(k=0;k<s;k++)
        for(l=0;l<6;l++)
         for(m=0;m<s;m++)       
      printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);
}

必须有某种方法可以明确地缩短这一时间。

说明

  • 将a，e，i，o，u，y的整数值存储在数值数组中，
  • 将所有字母存储在数组中，如果是元音，则用辅音替换，因此数组中存在重复的辅音值，
  • 删除了重复的辅音值，
  • 打印所有组合cvcvc。
— 亚伯汤姆
source
如果您可以放一个可以帮助您的非高尔夫版本。
— SIGSTACKFAULT
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.