Pour les besoins de ce défi, une polyphthong est définie comme une tranche contiguë d'une chaîne, qui ne contient que des voyelles et a une longueur d'au moins 2. Étant donné une chaîne non vide en entrée, votre tâche consiste à sortir toutes les polyphthongs qu'elle contient. .

Par exemple, "abeoic"a les tranches contiguës suivantes (séparées par des espaces):

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

En supprimant ceux qui contiennent autre chose que des voyelles, ou qui ont une longueur inférieure à 2, nous obtenons nos polyphthonges souhaitées:

eo oi eoi

Vos soumissions doivent respecter les règles suivantes:

• Vous pouvez choisir entre les minuscules ou les majuscules pour les E / S, mais le cas de sortie doit correspondre au cas d'entrée.

• Les voyelles sont aeiou(pour les minuscules) et AEIOU(pour les majuscules). y/ Yn'est pas considéré comme une voyelle.

• L'entrée ne contiendra que de l'ASCII imprimable.

• Si une polyphthong apparaît plusieurs fois, vous pouvez choisir de la sortir une seule fois ou de sortir toutes ses occurrences.

• Tout format et méthode d' E / S raisonnables sont autorisés (les listes de caractères sont également très bien, à la fois pour l'entrée et la sortie).

Cas de test

Entrée -> Sortie (en minuscules)

r67 ^^ () * 6536782! 87 -> []
programmation de puzzles et code golf -> []
aaand ... j'ai gagné! -> ['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']

Notez que pour les cas de test 3 et 6, vous pouvez sortir 'aa'et 'ee'respectivement une seule fois (voir la quatrième règle).

C'est le code-golf , la soumission la plus courte en octets dans toutes les langues gagne!

Python 2 , 102 97 octets

merci à @JonathanFrech pour -5 octets

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

Essayez-le en ligne!

E / S en minuscules

JavaScript (ES6), 77 75 octets

Attend l'entrée en minuscules. Produit des polyphthongs uniques sans répétition.

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

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

Comment?

Nous construisons récursivement l'arborescence de toutes les polyphthonges possibles, en élaguant les branches dès que le nœud actuel n'est plus contenu dans l'entrée et en enregistrant tous les nœuds correspondants d'au moins 2 caractères.

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

Rétine , 23 20 octets

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

Essayez-le en ligne!

Ceci imprime toutes les occurrences d'une polyphthong.

Explication

La rétine a un moyen d'obtenir tous les matchs qui se chevauchent , mais ce que cela signifie vraiment, c'est qu'elle cherchera un match de chaque position. Donc, s'il y a plusieurs correspondances à partir de la même position, cela n'en retournera qu'une seule. La seule façon d'obtenir vraiment tous les matchs qui se chevauchent est d'utiliser cette fonctionnalité deux fois, une fois de gauche à droite et une fois de droite à gauche (afin que nous obtenions d'abord la correspondance la plus longue possible de chaque position de départ possible, puis nous obtenons également toutes les correspondances pour les positions finales possibles).

Donc, le programme réel:

M!&`[aeiou]+

Obtenez toutes les séries de voyelles qui se chevauchent. Ce que cela signifie vraiment, c'est d'obtenir tous les suffixes de toutes les voyelles.

r!&`..+

Obtenez maintenant tous les préfixes qui sont au moins de longueur 2, en faisant correspondre de droite à gauche. Le Mest implicite ici, car c'est la dernière ligne du programme.

QuadS , 20 + 1 = 21 octets

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

avec le odrapeau

Essayez-le en ligne!

Dans l'ordre des choses:

[aeiou]+ sur chaque match de ce PCRE

,\⍵M préfixes du match

1↓ laissez tomber le premier (qui a une voyelle)

,/⍵ concaténer toutes les listes de préfixes

⊃ divulguer (parce que les réductions /incluent)

Cela équivaut à la fonction tacite Dyalog APL:

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

Essayez-le en ligne!

Mathematica, 92 octets

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

Essayez-le en ligne!

Java (OpenJDK 8) , 138 135 134 octets

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

Essayez-le en ligne!

J , 34 29 octets

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

Essayez-le en ligne!

Gelée , 9 octets

ẆḟÐḟØcḊÐf

Essayez-le en ligne!

Explication

ẆḟÐḟØ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 octets grâce à M. Xcoder

C (gcc) , 104 octets (99 octets en minuscules uniquement ou en majuscules uniquement)

Oui, ça fuit - alors quoi?

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

Essayez-le en ligne!

R , 137 octets

déjoué par 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]

Essayez-le en ligne!

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

Essayez-le en ligne

PowerShell , 93 88 octets

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

Essayez-le en ligne!

Utilise des E / S en minuscules ou en majuscules (ou un mix!).

Emprunte le code de ma réponse sur Exploded Substrings pour obtenir toutes les sous-chaînes, puis retire celles -matchcontre lesquelles regex ^[aeiou]{2,}$- c'est-à-dire celles qui ont au moins deux voyelles de longueur et seulement des voyelles. Ces chaînes sont laissées sur le pipeline et la sortie est implicite.

Haskell , 148 137 130 130 123 118 octets

Merci à @Laikoni pour -11 octets, encore -7 octets en me pointant vers des astuces de golf, encore -7 octets et encore -5 octets, pour un total énorme de -30 octets.

Cela semblait être un bon choix pour Haskell, mais le résultat ne semble pas être d'accord. Je suppose que Haskell était un choix OK après tout. Je suis toujours ennuyé par la façon dont subsequencesfonctionne.

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]

Essayez-le en ligne!

Perl, 45 octets

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

R , 120 octets 110 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

JavaScript (ES6), 105 octets

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

Il reste probablement beaucoup de golf à faire.

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 octets

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

Essayez-le en ligne!

05AB1E , 10 octets

Œʒg≠}ʒžMм_

Essayez-le en ligne!

Explications:

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

Une fonction acceptant un pointeur vers une entrée minuscule et produisant des chaînes séparées par des espaces sur la sortie standard:

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

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

Démo

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

Explication

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

En utilisant GCC sur Debian Linux, il me semble que je m'en tire avec les déclarations implicites incompatibles de strchr()et printf(). D'autres plateformes peuvent nécessiter <stdio.h>et <string.h>être incluses.

Essayez-le en ligne (nécessite Javascript).

APL (Dyalog) , 53 octets

Ceci est un Dfn( d IRECT f unctio n ). L'utilisation est p '<argument>'. Juste avertissement: ce n'est pas très efficace et input > 8 charactersexpire sur TIO, mais fonctionne normalement quand on lui donne suffisamment de temps.

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

Essayez-le en ligne!

Merci à @ Adám pour 16 octets!

Comment ça fonctionne:

Ceci est plus facile à comprendre si nous divisons le code en petites portions:

• Partie 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: Cette partie de la fonction prend la longueur de l'argument (à droite) et mélange le vecteur aeiouà lui-même autant de fois, produisant toutes les combinaisons possibles de [2, length(right arg)]voyelles.
• Partie 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: Cette partie vérifie quels éléments de G sont membres des sous-chaînes de l'entrée. Cela renvoie un vecteur booléen, avec 1's aux indices des combinaisons de voyelles présentes dans l'entrée et 0' s où elles ne le sont pas. Le vecteur résultant est ensuite mappé ( /) G, retournant les éléments correspondant aux valeurs véridiques.

Le tout est ensuite attribué à p. p←n'est pas inclus dans le nombre d'octets car ce n'est pas nécessaire , cela facilite simplement l'utilisation de la fonction.

Haskell , 74 octets

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

Essayez-le en ligne!

Ruby 2.4, 100 octets

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

C'est ma première tentative de golf, et je suis sûr qu'il existe de nombreuses façons de raccourcir ce code.

Ruby , 80 octets

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

Essayez-le en ligne!

Pyth , 15 octets

f&tT!-T"aeoi".:

Essayez-le en ligne!

Certainement jouable au golf, je veux l'améliorer avant d'écrire une explication.

T-SQL (SQL Server 2014), 281 octets

;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

Entrée donnée par

declare @ varchar(max) = 'abeoic'

Utilise une expression de table commune spour séparer l'entrée en lettres individuelles ordonnées, puis une deuxième expression de table commune cpour générer toutes les combinaisons ordonnées, en jetant des non-voyelles.

SQL Fiddle

PHP, 139 octets

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

Démo en ligne

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

Comment ça fonctionne

Sélectionnez des sous-chaînes (commençant par la longueur de 2) constituées de caractères adjacents et déplacez-vous le long de la chaîne. Collectez toutes les sous-chaînes qui ne contiennent que des voyelles. Répétez avec des sous-chaînes plus longues.

Pour la chaîne 'abcdef', voici les sous-chaînes générées et vérifiées:

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