Для целей этой задачи, полифонт определяется как непрерывный фрагмент строки, который содержит только гласные и имеет длину не менее 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 -> []
программирование головоломок и кода игры в гольф -> []
ааа ... я победил! -> ['аа', 'аа', 'ааа']
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

Попробуйте онлайн!

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,}$'}

Попробуйте онлайн!

Использует ввод / вывод в нижнем или верхнем регистре (или сочетание!).

Заимствует код из моего ответа на покомпонентных подстроках , чтобы получить все подстроки, а затем вытаскивает то , что регулярное выражение -matchпротив ^[aeiou]{2,}$- то есть те, которые по крайней мере , две гласные в длине и только гласные. Эти строки остаются в конвейере и вывод неявный.

Haskell , 148 137 130 123 118 байт

Спасибо @Laikoni за -11 байтов, еще -7 байтов, указав мне на подсказки для игры в гольф, еще -7 байтов и еще -5 байтов, в общей сложности колоссальные -30 байтов.

Это выглядело как хорошая подгонка для Хаскелла, но результат, похоже, не совпадает. Я полагаю, что Хаскелл был хорошим выбором в конце концов. Я все еще раздражен тем, как 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);
    }
}

Используя GCC в Debian Linux, я, кажется, сходит с рук несовместимыми неявными объявлениями strchr()и printf(). Другие платформы могут требовать <stdio.h>и <string.h>быть включены.

Попробуйте онлайн (требуется Javascript).

APL (Дьялог) , 53 байта

Это Dfn( д Прям ая е unctio п ). Использование есть p '<argument>'. Справедливое предупреждение: это не очень эффективно и время ожидания для input > 8 charactersTIO, но работает нормально, когда достаточно времени.

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

Попробуйте онлайн!

Спасибо @ Adám за 16 байтов!

Как это устроено:

Это легче понять, если мы разбиваем код на более мелкие части:

• Часть 1 G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: эта часть функции принимает длину (правого) аргумента и смешивает вектор aeiouс самим собой много раз, получая все возможные комбинации[2, length(right arg)] гласных.
• Часть 2 (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: эта часть проверяет, какие элементы из G являются членами подстрок ввода. Это возвращает логический вектор, с 1's' на индексах комбинаций гласных, которые присутствуют во входных данных, и 0там, где их нет. Полученный вектор затем отображается ( /) G, возвращая элементы, соответствующие истинным значениям.

Все это затем назначается p. p←не включается в число байтов, потому что это не обязательно , просто облегчает использование функции.

Haskell , 74 байта

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

Попробуйте онлайн!

Рубин 2.4, 100 байт

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

Это моя первая попытка игры в гольф, и я уверен, что есть много способов сократить этот код.

Рубин , 80 байт

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

Попробуйте онлайн!

Pyth , 15 байт

f&tT!-T"aeoi".:

Попробуйте онлайн!

Определенно пригодный для игры в гольф, я хочу получить это лучше прежде, чем написать объяснение.

T-SQL (SQL Server 2014), 281 байт

;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

Ввод дает

declare @ varchar(max) = 'abeoic'

Использует общее табличное выражение sдля разделения ввода на упорядоченные отдельные буквы, а затем второе общее табличное выражениеc для генерации всех упорядоченных комбинаций, выбрасывая не гласные.

SQL Fiddle

PHP, 139 байт

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

Онлайн демо

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

Как это устроено

Выберите подстроки (начиная с длины 2), состоящие из соседних символов, и двигайтесь вдоль строки. Соберите все подстроки, которые содержат только гласные. Повторите с более длинными подстроками.

Для строки 'abcdef' это сгенерированные и проверенные подстроки:

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