Đối với mục đích của thử thách này, một polyphthong được định nghĩa là một lát liền kề của Chuỗi, chỉ chứa nguyên âm và có độ dài ít nhất là 2. Với một Chuỗi không trống làm đầu vào, nhiệm vụ của bạn là xuất ra tất cả các đa âm mà nó chứa .

Ví dụ: "abeoic"có các lát liền kề sau (được phân tách bằng dấu cách):

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

Loại bỏ những thứ có chứa bất cứ thứ gì ngoài nguyên âm hoặc có độ dài nhỏ hơn 2, chúng ta sẽ có được các polyphthong mong muốn:

eo oi eoi

Nội dung gửi của bạn phải tuân thủ các quy tắc sau:

• Bạn có thể chọn chữ thường hoặc chữ hoa cho I / O, nhưng trường hợp đầu ra phải khớp với trường hợp đầu vào.

• Nguyên âm là aeiou(cho chữ thường) và AEIOU(cho chữ hoa). y/ Ykhông được coi là một nguyên âm.

• Đầu vào sẽ chỉ chứa ASCII có thể in được.

• Nếu một polyphthong xuất hiện nhiều lần, bạn có thể chọn chỉ xuất một lần hoặc xuất tất cả các lần xuất hiện của nó.

• Bất kỳ định dạng và phương thức I / O hợp lý nào đều được cho phép (danh sách các ký tự cũng ổn, cho cả đầu vào và đầu ra).

Các trường hợp thử nghiệm

Đầu vào -> Đầu ra (chữ thường)

r67 ^^ () * 6536782! 87 -> []
câu đố lập trình và mã golf -> []
aaand ... tôi đã thắng! -> ['aa', 'aa', 'aaa']
abeoic -> ['eo', 'oi', 'eoi']
yah eioo ala -> ['ei', 'io', 'oo', 'eio', 'ioo', 'eioo']
@yabeeeayio__e -> ['ee', 'ee', 'e', ​​'io', 'eee', 'eea', 'eeea']
0ioen0aaiosnjksd -> ['io', 'oe', 'aa', 'ai', 'io', 'ioe', 'aai', 'aio', 'aaio']

Lưu ý rằng đối với các trường hợp thử nghiệm 3 và 6, bạn có thể xuất ra 'aa'và 'ee'chỉ tương ứng một lần (Xem quy tắc thứ tư).

Đây là môn đánh gôn , bài nộp ngắn nhất theo byte trong mọi ngôn ngữ sẽ thắng!

Python 2 , 102 97 byte

cảm ơn @JonathanFrech cho -5 byte

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

Hãy thử trực tuyến!

chữ thường I / O

JavaScript (ES6), 77 75 byte

Mong đợi đầu vào bằng chữ thường. Đầu ra polyphthong độc đáo mà không lặp lại.

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

Các trường hợp thử nghiệm

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

Làm sao?

Chúng tôi xây dựng đệ quy cây của tất cả các polyphthong có thể, cắt tỉa các nhánh ngay khi nút hiện tại không còn trong đầu vào nữa và lưu tất cả các nút phù hợp với ít nhất 2 ký tự.

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

Võng mạc , 23 20 byte

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

Hãy thử trực tuyến!

Điều này in tất cả các lần xuất hiện của một polyphthong.

Giải trình

Retina có một cách để có được tất cả các trận đấu chồng chéo , nhưng điều này thực sự có nghĩa là nó sẽ tìm kiếm một trận đấu từ mỗi vị trí. Vì vậy, nếu có nhiều trận đấu từ cùng một vị trí, điều này sẽ chỉ trả lại một trong số chúng. Cách duy nhất để thực sự có được tất cả các trận đấu chồng chéo là sử dụng tính năng này hai lần, một lần khớp từ trái sang phải và một lần từ phải sang trái (để trước tiên chúng tôi có được trận đấu dài nhất có thể từ mỗi vị trí bắt đầu có thể, và sau đó chúng tôi cũng nhận được tất cả các trận đấu cho các vị trí kết thúc có thể).

Vì vậy, chương trình thực tế:

M!&`[aeiou]+

Nhận tất cả các nguyên âm chồng chéo. Điều này thực sự có nghĩa là để có được tất cả các hậu tố của tất cả các nguyên âm chạy.

r!&`..+

Bây giờ, nhận tất cả các tiền tố có độ dài ít nhất là 2, bằng cách khớp từ phải sang trái. Điều Mnày được ngầm định ở đây, bởi vì đó là dòng cuối cùng của chương trình.

QuadS , 20 + 1 = 21 byte

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

với ocờ

Hãy thử trực tuyến!

Theo thứ tự những điều xảy ra:

[aeiou]+ trên mỗi trận đấu của PCRE này

,\⍵M tiền tố của trận đấu

1↓ bỏ cái đầu tiên (trong đó có một nguyên âm)

,/⍵ nối tất cả các danh sách các tiền tố

⊃ tiết lộ (vì giảm /kèm theo)

Điều này tương đương với chức năng ngầm của Dyalog APL:

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

Hãy thử trực tuyến!

Toán học, 92 byte

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

Hãy thử trực tuyến!

Java (OpenJDK 8) , 138 135 134 byte

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

Hãy thử trực tuyến!

J , 34 29 byte

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

Hãy thử trực tuyến!

Thạch , 9 byte

ẆḟÐḟØcḊÐf

Hãy thử trực tuyến!

Giải trình

ẆḟÐḟØ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 byte nhờ ông Xcoder

C (gcc) , 104 byte (99 byte chỉ có chữ thường hoặc chỉ chữ hoa)

Vâng, nó bị rò rỉ - vậy thì sao?

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

Hãy thử trực tuyến!

R , 137 byte

bị đánh bại bởi Mark !

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]

Hãy thử trực tuyến!

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

Dùng thử trực tuyến

PowerShell , 93 88 byte

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

Hãy thử trực tuyến!

Sử dụng I / O chữ thường hoặc chữ hoa (hoặc kết hợp!).

Mượn mã từ câu trả lời của tôi trên Substrings đã nổ để có được tất cả các chuỗi con, sau đó rút ra những thứ mà regex -matchchống lại ^[aeiou]{2,}$- tức là những cái có ít nhất hai nguyên âm dài và chỉ có nguyên âm. Các chuỗi được để lại trên đường ống và đầu ra là ẩn.

Haskell , 148 137 130 123 118 byte

Cảm ơn @Laikoni cho -11 byte, hơn -7 byte bằng cách chỉ cho tôi các mẹo chơi gôn, -7 byte khác và -5 byte khác, với tổng số -30 byte.

Điều này có vẻ phù hợp với Haskell nhưng kết quả dường như không đồng ý. Tôi đoán rằng Haskell là một lựa chọn OK-ish sau tất cả. Tôi vẫn khó chịu bởi cách subsequenceslàm việc mặc dù.

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]

Hãy thử trực tuyến!

Perl, 45 byte

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

R , 120 byte 110 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 105 byte

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

Có lẽ có rất nhiều golf còn lại để làm.

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 byte

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

Hãy thử trực tuyến!

05AB1E , 10 byte

Œʒg≠}ʒžMм_

Hãy thử trực tuyến!

Giải thích:

Œʒ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 byte

Một hàm chấp nhận một con trỏ để nhập chữ thường và tạo các chuỗi được phân tách bằng dấu cách trên đầu ra tiêu chuẩn:

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

Chương trình kiểm tra

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

Bản giới thiệu

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

Giải trình

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

Sử dụng GCC trên Debian Linux, tôi dường như thoát khỏi các khai báo ngầm không tương thích của strchr()và printf(). Các nền tảng khác có thể yêu cầu <stdio.h>và<string.h> được bao gồm.

Hãy thử trực tuyến (yêu cầu Javascript).

APL (Dyalog) , 53 byte

Đây là một Dfn( d irect f unstio n ). Cách sử dụng là p '<argument>'. Cảnh báo công bằng: điều này không hiệu quả và hết thời gian cho input > 8 charactersTIO, nhưng hoạt động bình thường khi có đủ thời gian.

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

Hãy thử trực tuyến!

Cảm ơn @ Adám cho 16 byte!

Làm thế nào nó hoạt động:

Điều này dễ hiểu hơn nếu chúng ta phá mã theo các phần nhỏ hơn:

• Phần 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: Phần này của hàm lấy độ dài của đối số (phải) và trộn vectơ aeiouvới chính nó nhiều lần, mang lại mọi kết hợp có thể có của[2, length(right arg)] nguyên âm .
• Phần 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: Phần này kiểm tra (các) phần tử nào của G là thành viên của chuỗi con của đầu vào. Điều này trả về một vectơ boolean, với 1các chỉ số của các kết hợp nguyên âm có trong đầu vào và 0trong trường hợp không có. Vectơ kết quả sau đó được ánh xạ ( /) qua G, trả về các phần tử tương ứng với các giá trị trung thực.

Toàn bộ điều sau đó được giao cho p. p←không được bao gồm trong số byte bởi vì nó không cần thiết , nó chỉ làm cho việc sử dụng chức năng dễ dàng hơn.

Haskell , 74 byte

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

Hãy thử trực tuyến!

Ruby 2.4, 100 byte

(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]+$/}

Đây là nỗ lực đầu tiên của tôi khi chơi golf và tôi chắc chắn có rất nhiều cách để rút ngắn mã này.

Ruby , 80 byte

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

Hãy thử trực tuyến!

Bình thường , 15 byte

f&tT!-T"aeoi".:

Hãy thử trực tuyến!

Chắc chắn là có thể chơi gôn, tôi muốn làm cho nó tốt hơn trước khi viết ra lời giải thích.

T-SQL (SQL Server 2014), 281 byte

;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

Đầu vào cho bởi

declare @ varchar(max) = 'abeoic'

Sử dụng một biểu thức bảng chung sđể thổi đầu vào thành các chữ cái riêng lẻ được sắp xếp và sau đó một biểu thức bảng chung thứ hai cđể tạo ra tất cả các kết hợp có thứ tự, loại bỏ các nguyên âm không.

Câu đố SQL

PHP, 139 byte

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

Bản demo trực tuyến

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

Làm thế nào nó hoạt động

Chọn các chuỗi con (bắt đầu bằng độ dài 2) bao gồm các ký tự liền kề và di chuyển dọc theo chuỗi. Thu thập bất kỳ chuỗi con chỉ chứa nguyên âm. Lặp lại với các chuỗi con dài hơn.

Đối với chuỗi 'abcdef', đây là các chuỗi con được tạo và kiểm tra:

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