出于此挑战的目的，将polyphthong定义为String的连续切片，该切片仅包含元音，并且长度至少为2。给定非空String作为输入，您的任务是输出其包含的所有polyphthongs 。

例如，"abeoic"具有以下连续切片（以空格分隔）：

a b e o i c ab be eo oi ic abe beo eoi oic abeo beoi eoic abeoi beoic abeoic

除去那些不包含元音或长度小于2的元音，我们将得到所需的多音节：

eo oi eoi

您的提交必须遵守以下规则：

• 您可以为I / O选择小写或大写，但输出大小写必须与输入大小写匹配。

• 元音为aeiou（小写）和AEIOU（大写）。y/ Y不被视为元音。

• 输入将仅包含可打印的ASCII。

• 如果一个多重声部出现多次，则可以选择仅输出一次或输出所有出现的情况。

• 允许使用任何合理的I / O格式和方法（对于输入和输出，也可以使用字符列表）。

测试用例

输入->输出（小写）

r67 ^^（）* 6536782！87-> []
编程难题和代码高尔夫球-> []
aaand ...我赢了！-> ['aa'，'aa'，'aaa']
阿拉伯语-> ['eo'，'oi'，'eoi']
yah eioo ala-> ['ei'，'io'，'oo'，'eio'，'ioo'，'eioo']
@yabeeeayio__e-> ['ee'，'ee'，'ea'，'io'，'eee'，'eea'，'eeea']
0ioen0aaiosnjksd-> ['io'，'oe'，'aa'，'ai'，'io'，'ioe'，'aai'，'aio'，'aaio']

请注意，为测试案例3和6，您可以输出'aa'并'ee'分别只有一次（见第四条规则）。

这是代码高尔夫球，每种语言中以字节为单位的最短提交胜出！

Python 2中，102个 97字节

感谢@JonathanFrech -5个字节

w=input();l=range(len(w)+1)
print{w[a:b]for a in l for b in l if b-a>1<set(w[a:b])<=set('aeiou')}

在线尝试！

小写I / O

JavaScript（ES6），77 75字节

要求输入小写。输出唯一的多声群，而不重复。

w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

测试用例

let f =

w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

console.log(JSON.stringify(f("r67^^()*6536782!87")))
console.log(JSON.stringify(f("programming puzzles and code golf")))
console.log(JSON.stringify(f("aaand... i won!")))
console.log(JSON.stringify(f("abeoic")))
console.log(JSON.stringify(f("yah eioo ala")))
console.log(JSON.stringify(f("@yabeeeayio__e")))
console.log(JSON.stringify(f("0ioen0aaiosnjksd")))

怎么样？

我们以递归方式构建所有可能的polyphthongs的树，一旦输入中不再包含当前节点，就修剪分支，并保存至少两个字符的所有匹配节点。

w => (                      // given the input w
  r = [],                   // r = array of results
  g = s =>                  // g = recursive function taking s
    w.match(s) &&           // if w contains s:
    [...'aeiou'].map(c =>   //   for each vowel c:
      g(s + c),             //     do a recursive call with s + c
      s[1] &&               //     if s is at least 2-character long:
      r.push(s)             //       push it into r
    )                       //   end of map()
)``                         // initial call to g() with s = ''
&& r                        // return r

视网膜，23 20字节

M!&`[aeiou]+
r!&`..+

在线尝试！

这将打印所有出现的polyphthong。

说明

视网膜确实有一种方法来获取所有重叠的匹配项，但这实际上意味着它将从每个位置寻找一个匹配项。因此，如果同一位置有多个匹配项，则只会返回其中之一。真正获得所有重叠匹配项的唯一方法是使用此功能两次，一次从左至右匹配，一次从右至左匹配（以便我们首先从每个可能的起始位置获得最长的匹配项，然后我们还针对可能的结束位置）。

所以实际的程序是：

M!&`[aeiou]+

获取所有重叠的元音运行。这实际上意味着获得所有元音运行的所有后缀。

r!&`..+

现在，通过从右到左匹配，获取至少长度为2的所有前缀。这里M是隐式的，因为它是程序的最后一行。

QuadS，20 +1 = 21字节

⊃,/⍵
[aeiou]+
1↓,\⍵M

带有o标志

在线尝试！

按照发生的顺序：

[aeiou]+ 在此PCRE的每次比赛中

,\⍵M 匹配的前缀

1↓ 删除第一个（具有一个元音）

,/⍵ 连接所有前缀列表

⊃ 披露（因为/附有减免）

这等效于Dyalog APL的默认功能：

{⊃,/⍵}'[aeiou]+'⎕S{1↓,\⍵.Match}⍠'OM'1

在线尝试！

Mathematica，92个字节

Select[Join@@Partition[r,i,1]~Table~{i,2,Length[r=(S=Characters)@#]},SubsetQ[S@"aeiou",#]&]&

在线尝试！

的Java（OpenJDK的8） ，138个 135 134字节

s->{String e,x="";for(int i=0,j,y=s.length();i<=y;i++)for(j=y;j>i;x+=e.matches("[aeiou]{2,}")?e+" ":"")e=s.substring(i,j--);return x;}

在线尝试！

J，34 29字节

(*/@e.&'aeoui'*1<#)\\.#&,<\\.

在线尝试！

果冻，9字节

ẆḟÐḟØcḊÐf

在线尝试！

说明

ẆḟÐḟØcḊÐf  Main Link
Ẇ          Get all (contiguous) sublists
  Ðḟ       Filter; remove all elements where the result is truthy:
 ḟ  Øc     Filter; remove all vowels; if it's truthy, then it contains non-vowels
       Ðf  Filter; keep elements where the result is truthy:
      Ḋ    Dequeue; return all but the first element (truthy if the length was at least 2)

-4个字节感谢Xcoder先生

C（gcc），104个字节（99个字节，仅小写或仅大写）

是的，它泄漏了-那又如何？

#include<string.h>
a;f(char*s){*s&&f(s+1);for(a=strspn(s=strdup(s),"AEIOUaeiou");a>1;)s[a--]=0,puts(s);}

在线尝试！

R，137字节

马克超越了！

function(S)(x=unlist(sapply((s=el(strsplit(S,"[^aeiou]")))[nchar(s)>1],function(x)substring(x,1:(n=nchar(x)),rep(n:1,e=n)))))[nchar(x)>1]

在线尝试！

function(S){
 s <- el(strsplit(S,"[^aeiou]"))            # split on non-vowels
 s <- s[nchar(s)>1]                         # vowel groups of length at least 2
 p <- function(x){                          # generates all substrings of inputs
  n <- nchar(x)
  start <- 1:n
  stop <- rep(n:1, n)                       # this will generate dups
  substring(x, start, stop)

 }
 q <- unlist(sapply(s, p))                  # all substrings
 q <- q[nchar(q)>1]                         # all length-2 or more substrings
}

Perl 5，53 +1（-p）

/[aeiou]{2,}(?{$h{$&}++})(?!)/g;$_=join$",sort keys%h

在线试用

PowerShell，93 88字节

param($a)0..($b=$a.count-1)|%{($i=$_)..$b|%{-join$a[$i..$_]}}|?{$_-match'^[aeiou]{2,}$'}

在线尝试！

使用小写或大写I / O（或混合使用！）。

从我在Exploded Substrings上的答案中借用代码以获取所有子字符串，然后拉出那些正则表达式所-match针对的子字符串，^[aeiou]{2,}$即长度至少为两个元音且仅包含元音的那些。这些字符串留在管道上，输出是隐式的。

Haskell中，148 137 130 123 118字节

感谢@Laikoni提供-11个字节，将-7个字节指向高尔夫球技巧，再加上-7个字节，再加上-5个字节，进一步增加了-7个字节，总共有-30个字节。

对于Haskell来说，这看起来很合适，但结果似乎并不相同。我想Haskell毕竟是一个可以接受的选择。我仍然对subsequences工作方式感到恼火。

import Data.List
v=(`elem`"aeiou")
p s=nub$do x<-groupBy((.v).(&&).v)s;[y|y@(c:_:_)<-subsequences x,v c,y`isInfixOf`x]

在线尝试！

Perl，45个字节

local $,=" ";print $_=~/(?=([AEIOU]{2,}))/ig;

R，120字节 110字节

function(x){k=nchar(x);i=k:1;e=expand.grid(i,i[-1]);grep("^[aeiou]+$",mapply(substr,x,e[,2],e[,2]+e[,1]),v=T)}

在线尝试！

怎么运行的

function(x){                  #initalize the anonymous function where input is stored in x
  k=nchar(x)                  #set k to the number of characters in x
  i=k:1                       #create vector of integers from k to 1
  e=expand.grid(i,i[-1])      #create matrix of full outer join on i 
                              #except in the second column, limit i to being less than k
  grep("^[aeiou]+$",          #search for strings made of only vowels
       mapply(substr,         #map the substring function
              x,              #with x as the string to subset
              e[,2],          #start at the second column of the outer join
              e[,2]+e[,1]     #end at the sum of the sum of the first and second columns
       ),
       v=T                    #if a match is found, return it's value
  )
}                             #by default, R returns the last line of a function

C，119字节

f(char*s){*s&&f(s+1);char*t,*b=calloc(strlen(s),1);for(t=b;*s==65|*s==69|*s==73|*s==79|*s==85;b[1]&&puts(b))*t++=*s++;}

在线尝试！

JavaScript（ES6），105个字节

s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')

大概还有很多高尔夫球要做。

let f=
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')
console.log(JSON.stringify(f('r67^^()*6536782!87')))
console.log(JSON.stringify(f('programming puzzles and code golf')))
console.log(JSON.stringify(f('aaand... i won!')))
console.log(JSON.stringify(f('abeoic')))
console.log(JSON.stringify(f('yah eioo ala')))
console.log(JSON.stringify(f('@yabeeeayio__e')))
console.log(JSON.stringify(f('0ioen0aaiosnjksd')))

Perl 5，44 + 1（-n）= 45字节

map{say}/(?=([aeiou]{$.}))/g while$.++<y///c

在线尝试！

05AB1E，10个字节

Œʒg≠}ʒžMм_

在线尝试！

说明：

Œʒg≠}ʒžMм_  
Π           Push all substrings (abeoic => a, b, e, ..., eoi, eoc, ... abeioc)
 ʒ  }        Filter elements for which result is 1
  g≠            Push 1 if length is != 1, 0 otherwise
     ʒ       Filter elements for which result is 1
      žMм       Remove all occurences of 'aeiou' from element
         _      Negative bool: push 1 if length == 0, 0 otherwise

C，105 75字节

该函数接受指向小写输入的指针，并在标准输出上生成以空格分隔的字符串：

i;f(char*p){for(i=strspn(p,"aeiou");i>1;)printf("%.*s ",i--,p);*p&&f(p+1);}

测试程序

#include <stdio.h>

int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        char *in = argv[i];
        printf("'%s' -> [ ", in);
        f(in);
        puts("]");
    }
}

演示版

'r67^^()*6536782!87' -> [ ]
'programming puzzles and code golf' -> [ ]
'aaand... i won!' -> [ aaa aa aa ]
'abeoic' -> [ eoi eo oi ]
'yah eioo ala' -> [ eioo eio ei ioo io oo ]
'@yabeeeayio__e' -> [ eeea eee ee eea ee ea io ]
'0ioen0aaiosnjksd' -> [ ioe io oe aaio aai aa aio ai io ]

说明

#include <string.h>
#include <stdio.h>

void find_polyphthongs(char *p)
{
    /* from longest polyphthong substring down to 2 */
    for (int i = strspn(p,"aeiou");  i >= 2;  --i) {
        /* print exactly [p .. p+i] */
        printf("%.*s ", i, p);
    }

    /* tail-recurse to next char */
    if (*p) {
        find_polyphthongs(p+1);
    }
}

在Debian Linux上使用GCC，我似乎逃脱的不兼容的隐式声明的strchr()和printf()。其他平台可能需要<stdio.h>和<string.h>被包括在内。

在线尝试（需要Javascript）。

APL（Dyalog），53字节

这是一个Dfn（d I整流器˚F unctio Ñ）。用法是p '<argument>'。合理的警告：这不是很有效，并且input > 8 characters在TIO上超时，但是在有足够的时间时可以正常工作。

p←{(G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵}

在线尝试！

感谢@Adám提供16个字节！

怎么运行的：

如果我们将代码分成较小的部分，则更容易理解：

• Part 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: This part of the function takes the length of the (right) argument and mixes the vector aeiou to itself that many times, yielding every possible combination of [2, length(right arg)] vowels.
• Part 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: This part checks which element(s) of G are members of the substrings of the input. This returns a boolean vector, with 1's at the indices of the vowel combinations that are present in the input and 0's where they're not. The resulting vector is then mapped (/) over G, returning the elements corresponding to the truthy values.

The whole thing is then assigned to p. p← is not included in the byte count because it's not necessary, it just makes using the function easier.

Haskell, 74 bytes

f[]=[]
f(h:t)=filter(all(`elem`"aeiou"))[h:take i t|i<-[1..length t]]++f t

Try it online!

Ruby 2.4, 100 bytes

(2..(b=(a=gets).size-1)).to_a.flat_map{|i|(0..(b-i)).to_a.map{|j|a[j,i]}}.select{|k|k=~/^[aeiou]+$/}

This is my first attempt at golfing, and I'm sure there are lots of ways to shorten this code.

Ruby, 80 bytes

->s{[*0..z=s.size-2].product([*2..z]).map{|v|s[*v][/[aeiou]{2,}/]}.uniq.compact}

Try it online!

Pyth, 15 bytes

f&tT!-T"aeoi".:

Try it online!

Definitely golfable, I want to get it better before writing out explanation.

T-SQL (SQL Server 2014), 281 bytes

;with s as(select substring(@,1,1)C,stuff(@,1,1,'')D,1 R union all select substring(D,1,1),stuff(D,1,1,''),R+1from s where len(D)>0),c as(select R i,C w from s where C LIKE'[aeiou]'union all select R,w+C from c join s ON i+1=R where s.C LIKE'[aeiou]')select w from c where len(w)>1

Input give by

declare @ varchar(max) = 'abeoic'

Uses a common table expression s to blow the input apart into ordered individual letters, and then a second common table expression c to generate all ordered combinations, throwing out non vowels.

SQL Fiddle

PHP, 139 bytes

function y($s){$p=[];$l=strlen($s);for($i=2;$i<=$l;$i++)for($j=0;$j<=$l-$i;$j++)strspn($a=substr($s,$j,$i),'aeiou')==$i&&$p[]=$a;return$p;}

Online demo

function yreadable($s)
{
    $p = [];
    $l = strlen($s);
    for($i=2; $i<=$l; $i++)
        for($j=0; $j<=$l-$i; $j++)
            strspn($a=substr($s,$j,$i),'aeiou')==$i
            && $p[] = $a;
    return $p;
}

How it works

Select sub-strings (beginning with the length of 2) consisting of adjacent characters and move along string. Collect any sub-strings that only contain vowels. Repeat with longer sub-strings.

For string 'abcdef' these are the substrings generated and checked:

'ab','bc','cd','de','ef'
'abc','bcd','cde','def'
'abcd','bcde','cdef'
'abcde','bcdef',
'abcdef'