Para os propósitos deste desafio, um polifongo é definido como uma fatia contígua de uma String, que contém apenas vogais e tem comprimento pelo menos 2. Dada uma String não vazia como entrada, sua tarefa é gerar todos os polyphthongs que ele contém .

Por exemplo, "abeoic"possui as seguintes fatias contíguas (separadas por espaço):

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

Removendo aqueles que contêm algo além de vogais ou que têm comprimento menor que 2, obtemos os polifongues desejados:

eo oi eoi

Seus envios devem obedecer às seguintes regras:

• Você pode escolher minúsculas ou maiúsculas para E / S, mas o caso de saída deve corresponder ao caso de entrada.

• As vogais são aeiou(para minúsculas) e AEIOU(para maiúsculas). y/ Ynão é considerado uma vogal.

• A entrada conterá apenas ASCII imprimível.

• Se um polifongo aparecer várias vezes, você pode escolher produzi-lo apenas uma vez ou todas as suas ocorrências.

• Qualquer formato e método de E / S razoáveis são permitidos (listas de caracteres também são boas, tanto para entrada quanto para saída).

Casos de teste

Entrada -> Saída (minúscula)

r67 ^^ () * 6536782! 87 -> []
quebra-cabeças de programação e código de golfe -> []
aaand ... eu ganhei! -> ['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']

Observe que, nos casos de teste 3 e 6, você pode produzir 'aa'e, 'ee'respectivamente, apenas uma vez (consulte a quarta regra).

Este é o código-golfe , o menor envio em bytes em todos os idiomas vence!

Python 2 , 102 97 bytes

graças a @ JonathanFrech por -5 bytes

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

Experimente online!

E / S minúscula

JavaScript (ES6), 77 75 bytes

Espera entrada em minúsculas. Produz polifongos exclusivos sem repetir.

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

Casos de teste

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

Quão?

Criamos recursivamente a árvore de todos os polifongos possíveis, removendo ramificações assim que o nó atual não estiver mais contido na entrada e salvando todos os nós correspondentes de pelo menos 2 caracteres.

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

Retina , 23 20 bytes

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

Experimente online!

Isso imprime todas as ocorrências de um polifongo.

Explicação

O Retina tem uma maneira de obter todas as correspondências sobrepostas , mas o que isso realmente significa é que procurará uma correspondência de cada posição. Portanto, se houver várias correspondências da mesma posição, isso retornará apenas uma delas. A única maneira de realmente obter todas as correspondências sobrepostas é usar esse recurso duas vezes, uma vez correspondendo da esquerda para a direita e outra da direita para a esquerda (para que possamos obter a correspondência mais longa possível de cada posição inicial possível e, em seguida, também obteremos todas as correspondências para as possíveis posições finais).

Então, o programa atual:

M!&`[aeiou]+

Obtenha todas as execuções de vogais sobrepostas. O que isso realmente significa é obter todos os sufixos de todas as execuções de vogal.

r!&`..+

Agora obtenha todos os prefixos que tenham pelo menos o comprimento 2, correspondendo da direita para a esquerda. O Mestá implícito aqui, porque é a linha final do programa.

QuadS , 20 + 1 = 21 bytes

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

com a obandeira

Experimente online!

Para que as coisas aconteçam:

[aeiou]+ em cada partida deste PCRE

,\⍵M prefixos da partida

1↓ solte a primeira (que possui uma vogal)

,/⍵ concatenar todas as listas de prefixos

⊃ divulgar (porque as reduções /incluem)

Isso é equivalente à função tácita Dyalog APL:

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

Experimente online!

Mathematica, 92 bytes

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

Experimente online!

Java (OpenJDK 8) , 138 135 134 bytes

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

Experimente online!

J , 34 29 bytes

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

Experimente online!

Geléia , 9 bytes

ẆḟÐḟØcḊÐf

Experimente online!

Explicação

ẆḟÐḟØ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 bytes graças ao Sr. Xcoder

C (gcc) , 104 bytes (99 bytes apenas em minúsculas ou maiúsculas)

Sim, vaza - e daí?

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

Experimente online!

R , 137 bytes

superado por 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]

Experimente online!

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

Experimente Online

PowerShell , 93 88 bytes

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

Experimente online!

Usa E / S em minúsculas ou maiúsculas (ou uma mistura!).

Toma emprestado o código da minha resposta em Substrings explodidas para obter todas as subseqüências e, em seguida, retira aquelas que regex -matchcontra ^[aeiou]{2,}$- ou seja, aquelas que têm pelo menos duas vogais de comprimento e apenas vogais. Essas strings são deixadas no pipeline e a saída é implícita.

Haskell , 148 137 130 123 123 118 bytes

Graças a @Laikoni por -11 bytes, mais -7 bytes, apontando-me para dicas de golfe, outros -7 bytes e ainda outros -5 bytes, para um total de -30 bytes.

Isso pareceu um bom ajuste para Haskell, mas o resultado não parece concordar. Eu acho que Haskell era uma boa escolha, afinal. Ainda estou irritado com a maneira como subsequencesfunciona.

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]

Experimente online!

Perl, 45 bytes

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

R , 120 bytes 110 bytes

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

Experimente online!

Como funciona

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

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

Provavelmente ainda resta muito golfe para fazer.

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

Experimente online!

05AB1E , 10 bytes

Œʒg≠}ʒžMм_

Experimente online!

Explicações:

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

Uma função que aceita um ponteiro para entrada em minúscula e produz seqüências separadas por espaço na saída padrão:

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

Programa de teste

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

Explicação

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

Usando o GCC no Debian Linux, pareço me safar com as declarações implícitas incompatíveis de strchr()e printf(). Outras plataformas podem exigir <stdio.h>e <string.h>ser incluídas.

Experimente online (requer Javascript).

APL (Dyalog) , 53 bytes

Este é um Dfn( d espirre f unctio n ). O uso é p '<argument>'. Aviso justo: isso não é muito eficiente e input > 8 charactersatinge o tempo limite no TIO, mas funciona normalmente quando é dado tempo suficiente.

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

Experimente online!

Obrigado a @ Adám por 16 bytes!

Como funciona:

Isso é mais fácil de entender se quebrarmos o código em partes menores:

• Parte 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: Esta parte da função pega o comprimento do argumento (à direita) e mistura o vetor aeiouconsigo mesmo várias vezes, produzindo todas as combinações possíveis de [2, length(right arg)]vogais.
• Parte 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: Esta parte verifica quais elementos de G são membros das substrings da entrada. Isso retorna um vetor booleano, com 1s nos índices das combinações de vogais que estão presentes na entrada e 0onde eles não estão. O vetor resultante é então mapeado ( /) G, retornando os elementos correspondentes aos valores de verdade.

A coisa toda é então atribuída p. p←não é incluído na contagem de bytes porque não é necessário , apenas facilita o uso da função.

Haskell , 74 bytes

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

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

Esta é minha primeira tentativa de jogar golfe e tenho certeza de que há várias maneiras de diminuir esse código.

Ruby , 80 bytes

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

Experimente online!

Pitão , 15 bytes

f&tT!-T"aeoi".:

Experimente online!

Definitivamente jogável, quero melhorar antes de escrever uma explicação.

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

Entrada dada por

declare @ varchar(max) = 'abeoic'

Usa uma expressão de tabela comum spara separar a entrada em letras individuais ordenadas e, em seguida, uma segunda expressão de tabela comum cpara gerar todas as combinações ordenadas, jogando fora não vogais.

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

Demonstração online

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

Como funciona

Selecione as sub-strings (começando com o comprimento de 2) que consistem em caracteres adjacentes e mova-as ao longo da string. Colete quaisquer sub-strings que contenham apenas vogais. Repita com sub-strings mais longas.

Para a string 'abcdef', estas são as substrings geradas e verificadas:

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