Для цілей цього виклику поліфтон визначається як суміжний фрагмент рядка, який містить лише голосні голоси і має довжину не менше 2. Враховуючи не порожній рядок як вхід, ваше завдання - вивести всі поліфтонги, які він містить .

Наприклад, "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

Ваші матеріали повинні дотримуватися таких правил:

• Ви можете вибрати малі або великі регістри для вводу / виводу, але вихідний регістр повинен відповідати вхідному.

• Голосні звуки aeiou(для малих літер) та AEIOU(для великої літери). y/ Yне вважається голосним.

• Вхід буде містити тільки друкований ASCII.

• Якщо поліфтон з'являється кілька разів, ви можете вивести його лише один раз або вивести всі його виникнення.

• Дозволений будь-який розумний формат і спосіб вводу / виводу (списки символів також точні, як для введення, так і для виводу).

Випробування

Введення -> Вихід (малі літери)

r67 ^^ () * 6536782! 87 -> []
програмування головоломок та код-гольф -> []
ааа ... я переміг! -> ['aa', 'aa', 'aaa']
abeoic -> ['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')}

Спробуйте в Інтернеті!

малі введення / виведення

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

Як?

Ми рекурсивно будуємо дерево з усіх можливих багатогранників, обрізаючи гілки, як тільки поточний вузол більше не міститься у вході, і зберігаємо всі узгоджуючі вузли щонайменше з 2 символів.

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!&`..+

Спробуйте в Інтернеті!

Це друкує всі виникнення поліфтонга.

Пояснення

У Retina є спосіб отримати всі збіги, що збігаються , але це дійсно означає, що вона буде шукати по одній матчі з кожної позиції. Тож якщо з однієї позиції є кілька матчів, це поверне лише один із них. Єдиний спосіб реально отримати всі збіги, що збігаються, - використовувати цю функцію двічі, один раз порівнюючи ліворуч праворуч і один раз праворуч ліворуч (щоб ми спочатку отримували найдовший можливий збіг з кожної можливої ​​стартової позиції, а потім також отримували всі матчі за можливі кінцеві позиції).

Отже, власне програма:

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

Спробуйте в Інтернеті!

Математика, 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,}$'}

Спробуйте в Інтернеті!

Використовується введення / виведення малих чи великих літер (або суміш!).

Запозичує код з моєї відповіді на Exploded Substrings, щоб отримати всі підрядки, а потім витягує ті, -matchпроти яких пересуваються ^[aeiou]{2,}$- тобто ті, що мають принаймні два голосні і лише голосні. Ці рядки залишаються на конвеєрі і вихід неявний.

Хаскелл , 148 137 130 123 118 байт

Завдяки @Laikoni на -11 байт, далі -7 байт, вказуючи мені на поради щодо гри в гольф, ще -7 байт і ще -5 байт, в цілому колосальних -30 байт.

Це виглядало як добре для Haskell, але результат, схоже, не згоден. Я здогадуюсь Haskell був OK-ish вибір врешті-решт. Мені все одно дратує те, як 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 bytes

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

Try it online!

JavaScript (ES6), 105 bytes

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

Probably has a lot of golfing left to do.

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 bytes

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

Try it online!

05AB1E, 10 bytes

Œʒg≠}ʒžMм_

Try it online!

Explanations:

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

A function accepting a pointer to lowercase input, and producing space-separated strings on standard output:

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

Test program

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

Demo

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

Explanation

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

Using GCC on Debian Linux, I seem to get away with the incompatible implicit declarations of strchr() and printf(). Other platforms may require <stdio.h> and <string.h> to be included.

Try it online (requires Javascript).

APL (Dyalog), 53 bytes

This is a Dfn (direct function). Usage is p '<argument>'. Fair warning: this is not very efficient and times out for input > 8 characters on TIO, but works normally when given enough time.

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

Try it online!

Thanks to @Adám for 16 bytes!

How it works:

This is easier to understand if we break the code in smaller portions:

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