Na potrzeby tego wyzwania polifhong definiuje się jako ciągły kawałek struny , który zawiera tylko samogłoski i ma długość co najmniej 2. Biorąc pod uwagę niepusty ciąg jako dane wejściowe, Twoim zadaniem jest wyprowadzenie wszystkich zawartych w nim polifhongów .

Na przykład "abeoic"ma następujące ciągłe plasterki (oddzielone spacjami):

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

Usuwając te, które zawierają wszystko inne niż samogłoski lub mają długość mniejszą niż 2, otrzymujemy pożądane polifthongi:

eo oi eoi

Twoje zgłoszenia muszą być zgodne z następującymi zasadami:

• Możesz wybrać małe / wielkie litery dla I / O, ale wielkość wyjściowa musi być taka sama jak wielkość wejściowa.

• Samogłoski to aeiou(dla małych) i AEIOU(dla wielkich). y/ Ynie jest uważane za samogłoskę.

• Dane wejściowe będą zawierały tylko ASCII do wydruku.

• Jeśli polifthong pojawia się wiele razy, możesz zdecydować się na jego wydruk tylko raz lub wszystkie jego wystąpienia.

• Dowolny rozsądny format i metoda wejścia / wyjścia jest dozwolona (listy znaków są również w porządku, zarówno dla wejścia, jak i wyjścia).

Przypadki testowe

Wejście -> Wyjście (małe litery)

r67 ^^ () * 6536782! 87 -> []
programowanie zagadek i golfa kodowego -> []
aa ... wygrałem! -> [„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”]

Zauważ, że w przypadkach testowych 3 i 6 możesz wypisać dane 'aa'i 'ee'odpowiednio tylko raz (patrz czwarta reguła).

To jest golf golfowy , wygrywa najkrótsza przesyłka w bajtach w każdym języku!

Python 2 , 102 97 bajtów

dzięki @JonathanFrech za -5 bajtów

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

Wypróbuj online!

małe we / wy

JavaScript (ES6), 77 75 bajtów

Oczekuje wprowadzania małymi literami. Wyprowadza unikalne polifthongi bez powtarzania.

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

Przypadki testowe

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

W jaki sposób?

Rekurencyjnie budujemy drzewo wszystkich możliwych polifongów, przycinając gałęzie, gdy tylko aktualny węzeł nie jest już zawarty w danych wejściowych, i zapisując wszystkie pasujące węzły o długości co najmniej 2 znaków.

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

Siatkówka , 23 20 bajtów

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

Wypróbuj online!

Wyświetla wszystkie wystąpienia polifonga.

Wyjaśnienie

Retina ma sposób na uzyskanie wszystkich nakładających się meczów, ale tak naprawdę oznacza to, że będzie szukał jednego meczu z każdej pozycji. Więc jeśli istnieje wiele dopasowań z tej samej pozycji, spowoduje to zwrócenie tylko jednego z nich. Jedynym sposobem, aby naprawdę uzyskać wszystkie nakładające się mecze, jest skorzystanie z tej funkcji dwa razy, raz dopasowując od lewej do prawej i raz od prawej do lewej (aby najpierw uzyskać możliwie najdłuższe dopasowanie z każdej możliwej pozycji początkowej, a następnie uzyskać wszystkie dopasowania dla możliwe pozycje końcowe).

Właściwy program:

M!&`[aeiou]+

Zbierz wszystkie nakładające się serie samogłosek. To tak naprawdę oznacza uzyskanie wszystkich sufiksów wszystkich przebiegów samogłosek.

r!&`..+

Teraz uzyskaj wszystkie prefiksy o długości co najmniej 2, dopasowując od prawej do lewej. Jest Mto niejawne, ponieważ jest to ostatnia linia programu.

QuadS , 20 + 1 = 21 bajtów

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

z oflagą

Wypróbuj online!

W porządku rzeczy:

[aeiou]+ na każdym meczu tego PCRE

,\⍵M prefiksy meczu

1↓ upuść pierwszą (która ma jedną samogłoskę)

,/⍵ połącz wszystkie listy prefiksów

⊃ ujawnij (ponieważ ograniczenia /zawierają)

Jest to równoważne z milczącą funkcją Dyalog APL:

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

Wypróbuj online!

Mathematica, 92 bajty

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

Wypróbuj online!

Java (OpenJDK 8) , 138 135 134 bajtów

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

Wypróbuj online!

J , 34 29 bajtów

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

Wypróbuj online!

Galaretka , 9 bajtów

ẆḟÐḟØcḊÐf

Wypróbuj online!

Wyjaśnienie

ẆḟÐḟØ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 bajty dzięki Mr. Xcoder

C (gcc) , 104 bajty (99 bajtów tylko małymi lub tylko dużymi literami)

Tak, przecieka - co z tego?

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

Wypróbuj online!

R , 137 bajtów

rozgromiony przez Marka !

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]

Wypróbuj 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

Wypróbuj online

PowerShell , 93 88 bajtów

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

Wypróbuj online!

Wykorzystuje małe / duże litery we / wy (lub miks!).

Pożycza kod z moją odpowiedź na eksplodowała podciągi , aby uzyskać wszystkie podciągi, następnie wyciąga te to regex -matchprzeciw ^[aeiou]{2,}$- to znaczy te, które są co najmniej dwie samogłoski długości i tylko samogłoski. Te ciągi są pozostawione w potoku, a dane wyjściowe są niejawne.

Haskell , 148 137 130 123 118 bajtów

Dzięki @Laikoni za -11 bajtów, kolejne -7 bajtów, wskazując mi wskazówki do gry w golfa, kolejne -7 bajtów, a jeszcze kolejne -5 bajtów, co daje w sumie aż -30 bajtów.

Wyglądało to na dobre dopasowanie do Haskella, ale wynik nie wydaje się zgodny. Wydaje mi się, że Haskell był jednak w porządku. Nadal jednak denerwuje mnie sposób, w jaki subsequencesdziała.

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]

Wypróbuj online!

Perl, 45 bajtów

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

R , 120 bajtów 110 bajtów

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

Wypróbuj online!

Jak to działa

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 bajtów

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

Wypróbuj online!

JavaScript (ES6), 105 bajtów

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

Prawdopodobnie zostało jeszcze wiele do gry w golfa.

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 bajtów

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

Wypróbuj online!

05AB1E , 10 bajtów

Œʒg≠}ʒžMм_

Wypróbuj online!

Objaśnienia:

Œʒ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 bajtów

Funkcja akceptująca wskaźnik do małych liter i generująca ciągi rozdzielone spacjami na standardowym wyjściu:

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

Program testowy

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

Próbny

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

Wyjaśnienie

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

Używając GCC w systemie Debian Linux, wydaje mi się, że uciekam od niekompatybilnych niejawnych deklaracji strchr()iprintf() . Inne platformy mogą wymagać <stdio.h>i <string.h>zostać uwzględnione.

Wypróbuj online (wymaga Javascript).

APL (Dyalog) , 53 bajty

Jest to Dfn( d Skierować F unctio n ). Zastosowanie jest p '<argument>'. Uczciwe ostrzeżenie: nie jest to zbyt wydajne i czas oczekiwania input > 8 charactersna TIO, ale działa normalnie, gdy ma wystarczająco dużo czasu.

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

Wypróbuj online!

Dzięki @ Adám za 16 bajtów!

Jak to działa:

Łatwiej to zrozumieć, jeśli podzielimy kod na mniejsze części:

• Część 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: Ta część funkcji przyjmuje długość (prawego) argumentu i aeiouwiele razy miesza wektor z sobą, uzyskując każdą możliwą kombinację [2, length(right arg)]samogłosek.
• Część 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: Ta część sprawdza, które elementy G są członami podciągów danych wejściowych. Zwraca wektor boolowski, przy czym 1s są indeksami kombinacji samogłosek, które są obecne na wejściu i 0tam, gdzie ich nie ma. Powstały wektor jest następnie odwzorowywany ( /) G, zwracając elementy odpowiadające prawdziwym wartościom.

Całość jest następnie przypisana do p. p←nie jest uwzględniony w liczbie bajtów, ponieważ nie jest to konieczne , po prostu ułatwia korzystanie z funkcji.

Haskell , 74 bajty

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

Wypróbuj online!

Ruby 2.4, 100 bajtów

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

To moja pierwsza próba gry w golfa i jestem pewien, że istnieje wiele sposobów na skrócenie tego kodu.

Rubinowy , 80 bajtów

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

Wypróbuj online!

Pyth , 15 bajtów

f&tT!-T"aeoi".:

Wypróbuj online!

Zdecydowanie do gry w golfa, chcę poprawić to przed napisaniem wyjaśnienia.

T-SQL (SQL Server 2014), 281 bajtów

;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

Podaj dane przez

declare @ varchar(max) = 'abeoic'

Używa wspólnego wyrażenia stabelowego, aby rozdzielić dane wejściowe na uporządkowane pojedyncze litery, a następnie drugiego wspólnego wyrażenia tabelowegoc aby wygenerować wszystkie uporządkowane kombinacje, wyrzucając non-samogłoski.

SQL Fiddle

PHP, 139 bajtów

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

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

Jak to działa

Wybierz podciągi (zaczynając od długości 2) składające się z sąsiadujących znaków i poruszaj się wzdłuż ciągu. Zbierz wszystkie podciągi zawierające tylko samogłoski. Powtórz z dłuższymi podciągami.

W przypadku ciągu „abcdef” są to wygenerowane i sprawdzone podciągi:

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