Twoim zadaniem jest napisanie programu, który wyświetli czytelną listę co pięć liter słów o strukturze:

spółgłoska - samogłoska - spółgłoska - samogłoska - spółgłoska

Dane wyjściowe powinny być sortowane alfabetycznie z jednym słowem w wierszu i bez powtarzania dwóch słów. Może być małe lub wielkie, ale nie mieszane. Aby lista mogła zaczynać się i kończyć w ten sposób:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Samogłoski są - e - i - o - u - y , inne 20-angielskie litery alfabetu są spółgłoski. Słowa nie muszą być rzeczywistymi słowami słownikowymi. Najkrótszy kod wygrywa.

Uwaga: kilka lat temu natknąłem się na program na stronie uniwersyteckiej, który właśnie to zrobił. Okazało się, że moje imię i nazwisko pasują do ograniczenia cvcvc, a ja googlowałem.

Mathematica, 72 65 61 bajtów

Print@@@Tuples@{a=##/(b=#5#9#15#21#25#)&@@Alphabet[],b,a,b,a}

Do testowania, polecam zastąpienie Print@@@z ""<>#&/@. Mathematica wyświetli wtedy skróconą formę pokazującą kilka pierwszych i ostatnich słów, zamiast ciągłego drukowania 288 000 wierszy.

Wyjaśnienie

W końcu znalazłem zastosowanie do dzielenia ciągów. :)

Intryguje mnie możliwość dodawania lub mnożenia ciągów przez jakiś czas, ale rzeczywiste przypadki użycia są dość ograniczone. Chodzi przede wszystkim o to, że coś podobnego "foo"+"bar"lub "foo"*"bar"(a zatem krótka forma "foo""bar") jest całkowicie poprawne w Mathematica. Jednak tak naprawdę nie wie, co zrobić z ciągami w wyrażeniach arytmetycznych, więc te rzeczy pozostają niedocenione. Mathematica ma zastosowanie ogólnie obowiązujące uproszczeń chociaż. W szczególności ciągi znaków zostaną posortowane w porządku kanonicznym (co jest dość pomieszane w Mathematica, gdy zaczniesz sortować ciągi zawierające litery różnych przypadków, cyfr i nieliterów), co często jest łamaczem, ale nie ma tutaj znaczenia . Ponadto "abc""abc"zostanie uproszczony do"abc"^2(co jest problemem, gdy powtarzasz ciągi, ale my też tego nie mamy), a coś takiego "abc"/"abc"faktycznie anuluje (z którego będziemy nawet korzystać).

Więc co próbujemy tutaj grać w golfa? Potrzebujemy listy samogłosek i listy spółgłosek, abyśmy mogli je karmić, Tuplesaby wygenerować wszystkie możliwe kombinacje. Moje pierwsze podejście było naiwnym rozwiązaniem:

Characters@{a="bcdfghjklmnpqrstvwxz",b="aeiouy",a,b,a}

Ta zakodowana lista spółgłosek trochę boli. Mathematica ma Alphabetwbudowaną funkcję, która pozwoliłaby mi tego uniknąć, gdybym był w stanie usunąć samogłoski w tani sposób. Tutaj jest jednak trudniej. Najprostszym sposobem na usunięcie elementów jest Complement, ale ostatecznie jest to dłuższe, przy użyciu jednej z następujących opcji:

{a=Complement[Alphabet[],b=Characters@"aeiouy"],b,a,b,a}
{a=Complement[x=Alphabet[],b=x[[{1,5,9,15,21,25}]]],b,a,b,a}

(Pamiętaj, że nie musimy już stosować Characterssię do całości, ponieważ Alphabet[]podaje listę liter, a nie ciąg znaków).

Spróbujmy więc tego biznesu arytmetycznego. Jeśli reprezentujemy cały alfabet jako iloczyn liter zamiast listy, możemy usunąć litery przez prosty podział, z powodu reguły anulowania. To oszczędza wiele bajtów, ponieważ nie będziemy potrzebować Complement. Co więcej, "a""e""i""o""u""y"jest tak naprawdę bajtem krótszym niż Characters@"aeiouy". Robimy to z:

a=##/(b="a""e""i""o""u""y")&@@Alphabet[]

Gdzie przechowujemy produkty spółgłoski i samogłoski odpowiednio w ai b. Działa to poprzez napisanie funkcji, która zwielokrotnia wszystkie argumenty ##i dzieli je przez iloczyn samogłosek. Ta funkcja jest stosowana do listy alfabetycznej, która przekazuje każdą literę jako osobny argument.

Jak dotąd tak dobrze, ale teraz mamy

{a=##/(b="a""e""i""o""u""y")&@@Alphabet[],b,a,b,a}

jako argument do Tuples, a te rzeczy wciąż są produktami, a nie listami. Zwykle najkrótszym sposobem na naprawę jest umieszczenie List@@@z przodu, który ponownie zamienia produkty w listy. Niestety dodanie tych 7 bajtów wydłuża czas naiwności.

Okazuje się jednak, że Tupleswcale nie przejmuje się głowami list wewnętrznych. Jeśli zrobisz

Tuples[{f[1, 2], f[3, 4]}]

(Tak, dla nieokreślonego f.) Otrzymasz:

{{1, 3}, {1, 4}, {2, 3}, {2, 4}}

Tak jakbyś użył Listzamiast f. Możemy więc przekazać te produkty bezpośrednio Tuplesi nadal uzyskać właściwy wynik. To oszczędza 5 bajtów w stosunku do naiwnego podejścia przy użyciu dwóch zakodowanych ciągów.

Teraz "a""e""i""o""u""y"jest to wciąż dość irytujące. Ale poczekaj, możemy też tutaj zapisać kilka bajtów! Argumentami naszej funkcji są pojedyncze litery. Jeśli więc wybieramy odpowiednie argumenty, możemy użyć ich zamiast literałów łańcuchowych, co jest krótsze dla trzech z nich. Chcemy argumenty #(skrót #1), #5, #9, #15, #21i #25. Jeśli umieścimy #na końcu, nie musimy też dodawać żadnych, *aby je pomnożyć, ponieważ (regex) #\d+jest kompletnym tokenem, do którego nie można dołączyć żadnych cyfr innych niż cyfry. W efekcie #5#9#15#21#25#oszczędzamy kolejne 4 bajty.

Perl, 47 bajtów

#!perl -l
/((^|[aeiouy])[^aeiouy]){3}/&&print for a..1x5

Licząc shebang jako jeden.

Wypróbuj online!

Python 3 - 110 bajtów

a,b="bcdfghjklmnpqrstvwxz","aeiouy";print(*(c+d+e+f+g for c in a for d in b for e in a for f in b for g in a))

Prosta zabawa w zapętlanie :)

Ruby, 72 71 52 bajtów

puts (?z..?z*5).grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/

Dzięki Value Ink za podstawowy pomysł, który sprowadził to do 60 bajtów.

05AB1E , 18 16 bajtów

05AB1E wykorzystuje kodowanie CP-1252 .

žP3ãžO3ãâ€øJ€¨ê»

Wyjaśnienie

žP3ã                # push all combinations of 3 consonants
    žO3ã            # push all combinations of 3 vowels
        â           # cartesian product
         €ø         # zip each pair of [ccc,vvv] (c=consonant,v=vowel)
           J        # join to list of strings ['cvcvcv','cvcvcv' ...]
            ۬      # remove last vowel from each
              ê     # sort and remove duplicates
              »     # join on newlines

Do celów testowych zalecam zastąpienie žPkilkoma spółgłosek i žOkilkoma samogłoskami.

Przykład z użyciem 5 spółgłosek i 3 samogłosek

Python 2 , 120 102 94 bajty

from itertools import*
lambda:map(''.join,product(*(('AEIOUY','BCDFGHJKLMNPQRSTVWXZ')*3)[1:]))

Wypróbuj online!

Pure Bash, 74

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval echo $c$v$c$v$c

Prosta ekspansja nawiasów klamrowych.

Wypróbuj online .

Jeśli każdy element musi znajdować się w osobnej linii, mamy:

Pure Bash, 84

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval printf '%s\\n' $c$v$c$v$c

PHP, 88 86 84 80 bajtów

ładny przyrost łańcucha :)
6 bajtów zapisanych przez @Christoph

for($s=$v=aeiouy;++$s<zyzza;preg_match("#[^$v]([$v][^$v]){2}#",$s)&&print"$s
");

zapętla wszystkie ciągi od bababado zyzyzi sprawdza, czy pasują do wzorca. Uruchom z -nr.

MATL , 21 bajtów

11Y2'y'h2Y2X~6Myyy&Z*

Wypróbuj online! (ale dane wyjściowe są obcięte).

11Y2   % Push 'aeiou' (predefined literal)
'y'    % Push 'y'
h      % Concatenate: gives 'aeiouy'
2Y2    % Push 'abcdefghijklmnopqrstuvwxyz' (predefined literal)
X~     % Set symmetric difference: gives 'bcdfghjklmnpqrstvwxz'
6M     % Push 'aeiouy' again
yyy    % Duplicate the second-top element three times onto the top. The stack now
       % contains 'bcdfghjklmnpqrstvwxz', 'aeiouy', 'bcdfghjklmnpqrstvwxz',
       % 'aeiouy', 'bcdfghjklmnpqrstvwxz'
&Z*    % Cartesian product of all arrays present in the stack. Implicity display

Python, 92 bajty

f=lambda i=-4,s='':i*[s]or sum([f(i+1,s+c)for c in i%2*'AEIOUY'or'BCDFGHJKLMNPQRSTVWXZ'],[])

Nie mogę się itertoolswygrać. Iteratywny jest o 1 bajt dłużej w Pythonie 2.

W='',
for s in(['AEIOUY','BCDFGHJKLMNPQRSTVWXZ']*3)[1:]:W=[w+c for w in W for c in s]
print W

Haskell, 54 51 bajtów

l="bcdfghjklmnpqrstvwxz":"aeiouy":l
mapM(l!!)[0..4]

mapM func listbuduje wszystkie słowa, biorąc możliwe znaki dla indeksu i z listy zwróconej przez func (list!!i).

Edycja: @xnor znalazł 2 bajty do zapisania i patrząc na swoje rozwiązanie, znalazłem inny.

Brachylog , 18 bajtów

@W:@Dg:2jcb:eac@w\

Wypróbuj online!

Wyjaśnienie

@W:@D                 The list ["aeiouy", "bcdfghjklmnpqrstvwxz"]
     g:2jcb           The list ["bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz"]
           :ea        Take one character of each string
              c       Concatenate into a single string
               @w     Write to STDOUT followed by a newline
                 \    Backtrack: try other characters of the string

JavaScript (ES6), 91 90 bajtów

f=(s='',i=4)=>{for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')i?f(s+c,i-1):console.log(s+c)}

Edycje

• Produkcje ETH: -1 bajt poprzez usunięcie dodatkowej grupy wokół operatora trójskładnikowego w forinstrukcji

Wyjaśnienie

Definiuje to 5-głęboką funkcję rekurencyjną, która wykorzystuje parzystość głębokości wywołania, aby określić, czy iterować samogłoski czy spółgłosek. Przy każdej iteracji sprawdza, czy należy powtórzyć lub drukować, sprawdzając liczbę pozostałych rekurencji, i konkatenuje literę bieżącej iteracji do końca ciągu 5 znaków, który jest obecnie budowany jako głębia pierwsza.

Alternatywne 89-bajtowe rozwiązanie przy założeniu kodowania ISO8859-1:

f=(s='',i=4)=>{for(c of i%2?'aeiouy':btoa`mÇ_äi骻-¿s`)i?f(s+c,i-1):console.log(s+c)}

Alternatywne rozwiązanie 96-bajtowe, które zwraca całe dane wyjściowe jako pojedynczy ciąg:

f=(s='',i=4,o='')=>eval("for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')o+=i?f(s+c,i-1):s+c+`\n`")

Działaj na własne ryzyko. W przypadku rozwiązania 91-bajtowego wystarczy użyć, f()a w przypadku alternatywy 97-bajtowej użyć console.log(f()).

C, 201 199 186 184 183 169 163 bajtów

Robi to nieco inaczej niż w poprzedniej podstawowej metodzie liczenia:

f(){for(char*c="bcdfghjklmnpqrstvwxz",*v="aeiouy",i[5]={0},*s[]={c,v,c,v,c},j=0;j<5;puts("")){for(j=5;j--;putchar(s[j][i[j]]));for(;j++<5&&!s[j][++i[j]];i[j]=0);}}

Nie golfowany:

f() {
    for(char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[5]={0}, *s[]={c,v,c,v,c}, j=0; j<5; puts("")) {
        for (j=5; j--; putchar(s[j][i[j]])) ;
        for (; j++ < 5 && !s[j][++i[j]]; i[j]=0) ;
    }
}

I napisane w nieco bardziej konwencjonalny sposób:

f() {
    char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[]={0,0,0,0,0}, *s[]={c,v,c,v,c}, j=0;
    while (j>=0) {
        for (j=0; j<5; j++) putchar(s[j][i[j]]); // output the word
        while (--j>=0 && !s[j][++i[j]]) i[j]=0; // increment the counters
        puts("");
    }
}

Zasadniczo, i są licznikami, a s tablicą ciągów znaków zawierających wszystkie znaki, nad którymi powinniśmy iterować, dla każdego licznika. Trick jest wewnętrzną , a pętla: jest używany do zwiększania liczników, od na prawo. Jeśli zobaczymy, że następnym znakiem, który powinniśmy wyświetlić, jest kończący się znak zerowy, restartujemy licznik do zera, a „przeniesienie” zostanie propagowane do następnego licznika.

Dzięki Cristoph!

Perl, 71 bajtów

map{push@{1+/[aeiouy]/},$_}a..z;$"=",";say for glob"{@1}{@2}"x2 ."{@1}"

Wypróbuj online!

Wyjaśnienie

Dodam więcej wyjaśnień później.

map{push@{1+/[aeiouy]/},$_}a..z;tworzy dwie tablice: @1zawiera spółgłosek i @2samogłosek.
globkiedy wywołanie z argumentami takimi jak {a,b}{c,d}zwraca wszystkie permutacje elementów w nawiasach klamrowych.

Befunge, 95 bajtów

::45*%\45*/:6%\6/:45*%\45*/:6%\6/1g,2g,1g,2g,1g,55+,1+:"}0":**-!#@_
bcdfghjklmnpqrstvwxz
aeiouy

Wypróbuj online! , chociaż należy pamiętać, że dane wyjściowe zostaną obcięte.

Jest to po prostu pętla z zakresu od 0 do 287999, generująca indeks w postaci mieszanej liczby 20-6-20-6-20, z „cyframi” liczby pobranej z tabel w dwóch ostatnich wierszach.

Perl 6 , 70 bajtów

$_=<a e i o u y>;my \c=[grep .none,"a".."z"];.say for [X~] c,$_,c,$_,c

Wyjaśnienie interesującej części:

.say for [X~] c, $_, c, $_, c

              c, $_, c, $_, c  # list of five lists
         [X ]                  # lazily generate their Cartesian product
           ~                   # and string-concatenate each result
.say for                       # iterate to print each result

Wcześniejszy kod po prostu generuje listę samogłosek ( $_) i listę spółgłosek ( c), co jest niestety pełne.

Python 2 , 120 117 bajtów

Dzięki @WheatWizard za poradę dotyczącą zakładek.

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
for a in x:
 for e in x:
	for b in y:
		for c in y:
			for d in y:print b+a+c+e+d

Wypróbuj online!

Nie jestem pewien, czy można dużo golfa. Wypróbuj online obcina przy 128 KB, ale pokazuje wystarczająco dużo, aby dać pomysł. Lokalne uruchomienie z kodem debugowania do zliczenia słów dało w sumie 288000. Uruchamia się w około 45 sekund, jeśli ktoś chce przetestować.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Wersja niezgodna, a zatem niekonkurująca (drukuje tablice zagnieżdżone zamiast określonego formatu) dla 110 bajtów:

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
print[[[[c+a+d+b+e for e in y]for d in y]for c in y]for b in x]for a in x]

Perl 6, 53 bajtów

/<-[aeiouy]>**3%<[aeiouy]>/&&.say for [...] <a z>Xx 5

Zajmuje trochę czasu, aby mieć jakąkolwiek wydajność. Bardzo nieefektywne. Wykonuje pracę.

xeger , 49 bajtów

([bcdfghj-np-tvwxz][aeiouy]){2}[bcdfghj-np-tvwxz]

Biorąc pod uwagę wyrażenie regularne, xeger po prostu generuje wszystkie pasujące ciągi. Aby nie zabić przeglądarki, zatrzymuje się co 1000 wyników i musisz kliknąć, aby kontynuować, ale w końcu się tam dostanie.

Oto 23-bajtowa wersja z ^naprawionym błędem :

([:c^y][:v:y]){2}[:c^y]

Są to klasy znaków „wszystkie spółgłoski ASCII pisane małymi literami” [:c]z ywyłączeniem ^y, i „wszystkie samogłoski ASCII pisane małymi literami” [:v:]z ydodanym.

JavaScript (Firefox 30-57), 82 bajty

f=(i=5)=>i?[for(s of f(i-1))for(c of i%2?'bcdfghjklmnpqrstvwxz':'aeiouy')s+c]:['']

Zwraca tablicę ciągów. Bardzo szybka wersja dla 102 101 (1 bajt dzięki @ETHproductions) bajtów:

_=>[for(i of c='bcdfghjklmnpqrstvwxz')for(j of v='aeiouy')for(k of c)for(l of v)for(m of c)i+j+k+l+m]

CJam , 32 31 29 28 bajtów

Zaoszczędzono 2 bajty dzięki Martinowi Enderowi i 1 bajt dzięki Kaine'owi

"aeiouy"_'{,97>^\1$1$1$N]:m*

Wypróbuj online! (Zauważ, że wyjście zostaje odcięte w TIO)

Wyjaśnienie

"aeiouy"_ e# Push the six vowels and duplicate
'{,97>    e# Push the whole alphabet
^         e# Symmetric set difference of the alphabet with the vowels, yields the consonants only
\         e# Swap top two elements
1$1$1$    e# Copy the second-from-the-top string to the top three times
          e# This results in the array being consonants-vowels-consonants-vowels-consonants
N         e# Add a newline character to the end of the list
]         e# End an array. Puts everything done so far in an array
          e# since there was no explicit start of the array.
:m*       e# Reduce the array using Cartesian products

Ułożone, niekonkurencyjne, 51 bajtów

(consonants:@c vowels:@v c v c)multicartprod$outmap

Dość proste. Wypróbuj tutaj!

Perl, 63 59 54 bajtów

$a="aeiouy";$b="[^$a][$a]"x2;for("a"x5.."z"x5){say if/$b[^$a]/}

$a="aeiouy";$b="[^$a][$a]"x2;/$b[^$a]/&&say for"a"x5.."z"x5

$a=aeiouy;$b="[^$a][$a]"x2;/$b[^$a]/&&say for a.."z"x5

Dla odmiany wypróbowanie golfa Perla.
EDYCJA: Wygląda na to , że muszę się jeszcze wiele nauczyć ... :)

Scala, 87 86 bajtów

val a="aeiouy"
val b='a'to'z'diff a
for(c<-b;d<-a;e<-b;f<-a;g<-b)println(""+c+d+e+f+g)

R, 143 132 bajty

q=letters;v=c(1,5,9,15,21,25);x=list(q[-v],q[v],q[-v],q[v],q[-v]);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(sapply(x,length))))

q=letters;v=c(1,5,9,15,21,25);x=list(a<-q[-v],b<-q[v],a,b,a);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(lengths(x))))

To moja pierwsza gra w golfa Code, więc chętnie przyjmę wszelkie sugestie, aby ją jeszcze bardziej pogłębić. Jak dotąd wszystko jest dość standardowe R; jedyną możliwą trudną rzeczą jest to, że paste0 przetwarza swoje argumenty na długość najdłuższego.

Edycja: używana sztuczka przypisania z rturnbull, zastąpiona sapply(x,length)przez lengths.

R, 111 98 bajtów

Dodane yjako samogłoska i odgrane 13 bajtów dzięki @Patrick B.

l=letters
v=c(1,5,9,15,21,25)
apply(expand.grid(C<-l[-v],V<-l[v],C,V,C)[,5:1],1,cat,fill=T,sep="")

Używamy expand.griddo generowania wszystkich możliwych kombinacji Viw Cmacierzy, które definiujemy ze wstępnie ustawionej zmiennej letters(alfabetu). Odwracamy kombinacje (domyślnie pierwsza zmienna obraca się najszybciej), aby zapewnić kolejność alfabetyczną. Następnie iterujemy każdy rząd matrycy, drukując każdą literę na standardowe wyjście. Używamy tego fillargumentu, aby catupewnić się, że każde słowo zaczyna się od nowej linii.

Clojure, 101 bajtów

(print(apply str(for[V["aeiouy"]C["bcdfghjklmnpqrstvwxz"]a C b V c C d V e C](str a b c d e "\n")))))

Nie takie ekscytujące ...

Rubin, 65 61 bajtów

Zupełnie inne podejście:

(b=[*?a..?z]-a="aeiouy".chars).product(a,b,a,b){|x|puts x*""}

Nowe rzeczy, których się dziś nauczyłem: funkcja produktu Array #

C 361 bajtów

f(){i,j,k,l,m;v[6]={97,101,105,111,117,121};c[25];s=26;for(i=0;i<26;i++)c[i]=97+i;for(i=0;i<26;i++){for(j=0;j<6;j++)if(c[i]==v[j])c[i]+=1;}for(i=0;i<s;i++)for(j=i+1;j<s;){ if(c[i]==c[j]){for(k=j;k<s-1;++k)c[k]=c[k+1];--s;}else ++j;}for(i=0;i<s;i++)for(j=0;j<6;j++)for(k=0;k<s;k++)for(l=0;l<6;l++)for(m=0;m<s;m++)printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);}

Wersja bez golfa:

void f()
{   
int i,j, k,l,m;
int s=26;
int v[6]={97,101,105,111,117,121};
int c[s];

for(i=0;i<s;i++)
 c[i]=97+i;
for(i=0;i<s;i++)
{     
  for(j=0;j<6;j++)
    if(c[i]==v[j])
      c[i]+=1;
     }
for(i=0;i<s;i++)
 for(j=i+1;j<s;)
 { if(c[i]==c[j])
  {
    for(k=j;k<s-1;++k)
      c[k]=c[k+1];
      --s;  
  }else
   ++j;  
  }
for(i=0;i<s;i++)
  for(j=0;j<6;j++)
       for(k=0;k<s;k++)
        for(l=0;l<6;l++)
         for(m=0;m<s;m++)       
      printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);
}

Musi być jakiś sposób, aby to zdecydowanie skrócić.

Wyjaśnienie

• Zapisano wartości całkowite a, e, i, o, u, y w tablicy numerycznej,
• Przechowałem wszystkie alfabety w tablicy, jeśli była samogłoską, zastąpił ją spółgłoską, więc w tablicy były zduplikowane wartości spółgłoski,
• Usunięto zduplikowane wartości spółgłosek,
• Wydrukowano wszystkie kombinacje cvcvc.