Para los propósitos de este desafío, un polifongo se define como una porción contigua de una Cadena, que solo contiene vocales, y tiene una longitud de al menos 2. Dada una Cadena no vacía como entrada, su tarea es generar todos los polifongos que contiene .

Por ejemplo, "abeoic"tiene los siguientes sectores contiguos (separados por espacios):

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

Eliminando aquellos que contengan algo que no sean vocales, o que tengan una longitud menor a 2, obtenemos nuestros polifonos:

eo oi eoi

Sus presentaciones deben cumplir con las siguientes reglas:

• Puede elegir minúsculas o mayúsculas para E / S, pero el caso de salida debe coincidir con el caso de entrada.

• Las vocales son aeiou(para minúsculas) y AEIOU(para mayúsculas). y/ Yno se considera una vocal.

• La entrada solo contendrá ASCII imprimible.

• Si un polifongo aparece varias veces, puede optar por generarlo solo una vez o generar todas sus ocurrencias.

• Se permite cualquier formato y método de E / S razonable (las listas de caracteres también están bien, tanto para entrada como para salida).

Casos de prueba

Entrada -> Salida (minúsculas)

r67 ^^ () * 6536782! 87 -> []
programación de rompecabezas y código de golf -> []
aaand ... gané! -> ['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']

Tenga en cuenta que para los casos de prueba 3 y 6, puede generar 'aa'y 'ee'respectivamente solo una vez (consulte la cuarta regla).

Este es el código de golf , ¡el envío más corto en bytes en cada idioma gana!

Python 2 , 102 97 bytes

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

Pruébalo en línea!

E / S en minúsculas

JavaScript (ES6), 77 75 bytes

Espera entrada en minúsculas. Produce polifongos únicos sin repetir.

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

Casos de prueba

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

¿Cómo?

Construimos recursivamente el árbol de todos los polifongos posibles, podamos ramas tan pronto como el nodo actual ya no está contenido en la entrada y guardamos todos los nodos coincidentes de al 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!&`..+

Pruébalo en línea!

Esto imprime todas las ocurrencias de un polifongo.

Explicación

La retina tiene una manera de obtener todas las coincidencias superpuestas , pero lo que esto realmente significa es que buscará una coincidencia desde cada posición. Entonces, si hay múltiples coincidencias desde la misma posición, esto solo devolverá una de ellas. La única forma de obtener realmente todas las coincidencias superpuestas es usar esta función dos veces, una vez que coincida de izquierda a derecha y una vez de derecha a izquierda (para que primero obtengamos la coincidencia más larga posible de cada posición de inicio posible, y luego también obtengamos todas las coincidencias para las posibles posiciones finales).

Entonces el programa real:

M!&`[aeiou]+

Obtén todas las series de vocales superpuestas Lo que esto realmente significa es obtener todos los sufijos de todas las vocales.

r!&`..+

Ahora obtenga todos los prefijos que tengan al menos la longitud 2, haciendo coincidir de derecha a izquierda. El Mestá implícito aquí, porque es la última línea del programa.

QuadS , 20 + 1 = 21 bytes

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

con la obandera

Pruébalo en línea!

En orden de cosas que suceden:

[aeiou]+ en cada partido de este PCRE

,\⍵M prefijos del partido

1↓ soltar el primero (que tiene una vocal)

,/⍵ concatenar todas las listas de prefijos

⊃ revelar (porque las reducciones /incluyen)

Esto es equivalente a la función tácita Dyalog APL:

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

Pruébalo en línea!

Mathematica, 92 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

J , 34 29 bytes

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

Pruébalo en línea!

Jalea , 9 bytes

ẆḟÐḟØcḊÐf

Pruébalo en línea!

Explicación

ẆḟÐḟØ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 gracias al Sr. Xcoder

C (gcc) , 104 bytes (99 bytes solo en minúsculas o mayúsculas)

Sí, se filtra, ¿y qué?

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

Pruébalo en línea!

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]

Pruébalo en línea!

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

Pruébalo en línea

PowerShell , 93 88 bytes

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

Pruébalo en línea!

Utiliza E / S en minúsculas o mayúsculas (¡o una mezcla!).

Toma prestado el código de mi respuesta en Subcadenas explotadas para obtener todas las subcadenas, luego extrae las que tienen expresiones regulares -matchcontra^[aeiou]{2,}$ , es decir, aquellas que tienen al menos dos vocales de longitud y solo vocales. Esas cadenas se dejan en la tubería y la salida es implícita.

Haskell , 148 137 130 123 118 bytes

Gracias a @Laikoni por -11 bytes, más -7 bytes al señalarme consejos de golf, otros -7 bytes y otros -5 bytes, para un total de -30 bytes.

Esto parecía una buena opción para Haskell, pero el resultado no parece estar de acuerdo. Supongo que Haskell fue una elección aceptable después de todo. Sin embargo, todavía estoy molesto por la forma en que 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]

Pruébalo en línea!

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

Pruébalo en línea!

Cómo 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++;}

Pruébalo en línea!

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

Probablemente tiene mucho golf por hacer.

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

Pruébalo en línea!

05AB1E , 10 bytes

Œʒg≠}ʒžMм_

Pruébalo en línea!

Explicaciones:

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

Una función que acepta un puntero a la entrada en minúsculas y produce cadenas separadas por espacios en la salida estándar:

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

Programa de prueba

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

Manifestación

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

Explicación

#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 GCC en Debian Linux, parece que me salgo con las declaraciones implícitas incompatibles de strchr()y printf(). Otras plataformas pueden requerir <stdio.h>y<string.h> ser incluidas.

Pruébelo en línea (requiere Javascript).

APL (Dyalog) , 53 bytes

Esta es una Dfn( d directo teléfono f unctio n ). El uso es p '<argument>'. Advertencia justa: esto no es muy eficiente y se agota el tiempo de espera input > 8 charactersen TIO, pero funciona normalmente cuando se le da suficiente tiempo.

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

Pruébalo en línea!

¡Gracias a @ Adám por 16 bytes!

Cómo funciona:

Esto es más fácil de entender si dividimos el código en porciones más pequeñas:

• Parte 1 G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: esta parte de la función toma la longitud del argumento (derecho) y mezcla el vector aeiouconsigo mismo tantas veces, produciendo todas las combinaciones posibles de[2, length(right arg)] vocales.
• Parte 2 (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: esta parte verifica qué elemento (s) de G son miembros de las subcadenas de la entrada. Esto devuelve un vector booleano, con 1's en los índices de las combinaciones de vocales que están presentes en la entrada y 0' s donde no están. El vector resultante se mapea ( /) G, devolviendo los elementos correspondientes a los valores de verdad.

Todo esto se asigna a p. p←no está incluido en el recuento de bytes porque no es necesario , solo facilita el uso de la función.

Haskell , 74 bytes

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

Pruébalo en línea!

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

Este es mi primer intento de jugar al golf, y estoy seguro de que hay muchas maneras de acortar este código.

Rubí , 80 bytes.

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

Pruébalo en línea!

Pyth , 15 bytes

f&tT!-T"aeoi".:

Pruébalo en línea!

Definitivamente golfable, quiero mejorarlo antes de escribir una explicación.

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'

Utiliza una expresión de tabla común spara separar la entrada en letras individuales ordenadas y luego una segunda expresión de tabla comúnc para generar todas las combinaciones ordenadas, arrojando no vocales.

Violín de SQL

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

Demostración en línea

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

Cómo funciona

Seleccione subcadenas (comenzando con la longitud de 2) que consisten en caracteres adyacentes y muévase a lo largo de la cadena. Recoge cualquier subcadena que solo contenga vocales. Repita con subcadenas más largas.

Para la cadena 'abcdef', estas son las subcadenas generadas y verificadas:

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