Ai fini di questa sfida, un polittongo è definito come una porzione contigua di una stringa, che contiene solo vocali e ha una lunghezza di almeno 2. Data una stringa non vuota come input, il tuo compito è quello di produrre tutti i polittonghi che contiene .

Ad esempio, "abeoic"ha le seguenti sezioni contigue (separate da spazio):

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

Rimuovendo quelli che contengono qualcosa di diverso dalle vocali o che hanno una lunghezza inferiore a 2, otteniamo i polifonghi desiderati:

eo oi eoi

I tuoi invii devono rispettare le seguenti regole:

• È possibile scegliere lettere minuscole o maiuscole per l'I / O, ma il caso di output deve corrispondere al caso di input.

• Le vocali sono aeiou(per le lettere minuscole) e AEIOU(per le lettere maiuscole). y/ Ynon è considerata una vocale.

• L'input conterrà solo ASCII stampabile.

• Se un polifago compare più volte, è possibile scegliere di emetterlo una sola volta o di emetterne tutte le occorrenze.

• È consentito qualsiasi formato e metodo I / O ragionevole (anche gli elenchi di caratteri vanno bene, sia per l'input che per l'output).

Casi test

Ingresso -> Uscita (minuscolo)

r67 ^^ () * 6536782! 87 -> []
puzzle di programmazione e code golf -> []
e ... ho vinto! -> ['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']

Si noti che per i casi di test 3 e 6, è possibile eseguire l'output 'aa'e 'ee'rispettivamente una sola volta (vedere la quarta regola).

Questo è code-golf , vince l'invio più breve in byte in ogni lingua!

Python 2 , 102 97 byte

grazie a @JonathanFrech per -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')}

Provalo online!

I / O minuscoli

JavaScript (ES6), 77 75 byte

Prevede input in lettere minuscole. Produce polifonghi unici senza ripetizione.

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

Casi test

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

Come?

Costruiamo in modo ricorsivo l'albero di tutti i possibili politoftong, potando i rami non appena il nodo corrente non è più contenuto nell'input e salvando tutti i nodi corrispondenti di almeno 2 caratteri.

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 byte

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

Provalo online!

Ciò stampa tutte le occorrenze di un polittongo.

Spiegazione

Retina ha un modo per ottenere tutte le partite sovrapposte , ma ciò significa davvero che cercherà una partita per ogni posizione. Quindi, se ci sono più corrispondenze dalla stessa posizione, questo restituirà solo una di esse. L'unico modo per ottenere davvero tutte le partite sovrapposte è utilizzare questa funzione due volte, una volta abbinata da sinistra a destra e una volta da destra a sinistra (in modo da ottenere prima la corrispondenza più lunga possibile da ogni posizione iniziale possibile, quindi poi ottenere anche tutte le partite per le possibili posizioni finali).

Quindi il programma attuale:

M!&`[aeiou]+

Ottieni tutte le serie sovrapposte di vocali. Ciò significa veramente ottenere tutti i suffissi di tutte le corse vocaliche.

r!&`..+

Ora ottieni tutti i prefissi che sono almeno della lunghezza 2, facendo corrispondere da destra a sinistra. Qui Mè implicito, perché è l'ultima riga del programma.

QuadS , 20 + 1 = 21 byte

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

con la obandiera

Provalo online!

In ordine di cose:

[aeiou]+ su ogni partita di questo PCRE

,\⍵M prefissi della partita

1↓ rilascia il primo (che ha una vocale)

,/⍵ concatena tutti gli elenchi di prefissi

⊃ rivelare (perché le riduzioni /allegano)

Ciò equivale alla funzione tacita Dyalog APL:

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

Provalo online!

Mathematica, 92 byte

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

Provalo online!

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

Provalo online!

J , 34 29 byte

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

Provalo online!

Gelatina , 9 byte

ẆḟÐḟØcḊÐf

Provalo online!

Spiegazione

ẆḟÐḟØ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 grazie a Mr. Xcoder

C (gcc) , 104 byte (99 byte con solo lettere minuscole o solo lettere maiuscole)

Sì, perde - e allora?

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

Provalo online!

R , 137 byte

superato da 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]

Provalo 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

Provalo online

PowerShell , 93 88 byte

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

Provalo online!

Utilizza I / O minuscoli o maiuscoli (o un mix!).

Prende in prestito il codice dalla mia risposta Sottostringa esplosa per ottenere tutte le sottostringhe, quindi estrae quelle -matchcontro cui si regexano ^[aeiou]{2,}$, cioè quelle che sono lunghe almeno due vocali e solo vocali. Tali stringhe vengono lasciate sulla pipeline e l'output è implicito.

Haskell , 148 137 130 123 118 byte

Grazie a @Laikoni per -11 byte, ulteriori -7 byte indicandomi le punte del golf, altri -7 byte e ancora altri -5 byte, per un totale di ben -30 byte.

Sembrava una buona scelta per Haskell ma il risultato non sembra essere d'accordo. Penso che Haskell sia stata una scelta OK dopo tutto. Sono comunque seccato dal modo in cui subsequencesfunziona.

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]

Provalo online!

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

Provalo online!

Come funziona

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

Provalo online!

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

Probabilmente ha ancora molto da fare.

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

Provalo online!

05AB1E , 10 byte

Œʒg≠}ʒžMм_

Provalo online!

spiegazioni:

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

Una funzione che accetta un puntatore all'input in minuscolo e produce stringhe separate da spazio sull'output standard:

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

Programma di test

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

dimostrazione

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

Spiegazione

#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 su Debian Linux, mi sembra di cavarmela con le dichiarazioni implicite incompatibili di strchr()e printf(). Altre piattaforme potrebbero richiedere<stdio.h> e<string.h> essere incluse.

Provalo online (richiede Javascript).

APL (Dyalog) , 53 byte

Si tratta di una Dfn( d ire f unctio n ). L'uso è p '<argument>'. Avviso equo: questo non è molto efficiente e input > 8 charactersscade per TIO, ma funziona normalmente quando viene concesso abbastanza tempo.

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

Provalo online!

Grazie a @ Adám per 16 byte!

Come funziona:

Questo è più facile da capire se suddividiamo il codice in porzioni più piccole:

• Parte 1 G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: questa parte della funzione prende la lunghezza dell'argomento (a destra) e mescola il vettore aeioua se stesso molte volte, producendo ogni possibile combinazione di[2, length(right arg)] vocali.
• Parte 2 (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: questa parte controlla quali elementi di G sono membri delle sottostringhe dell'input. Ciò restituisce un vettore booleano, con 1gli indici delle combinazioni vocali presenti nell'input e 0dove non lo sono. Il vettore risultante viene quindi mappato ( /) sopra G, restituendo gli elementi corrispondenti ai valori di verità.

Il tutto viene quindi assegnato a p. p←non è incluso nel conteggio dei byte perché non è necessario , ma semplifica l'utilizzo della funzione.

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'