Nhiệm vụ của bạn là viết một chương trình sẽ đưa ra một danh sách dễ đọc của mỗi năm chữ cái có cấu trúc:

phụ âm - nguyên âm - phụ âm - nguyên âm - phụ âm

Đầu ra phải được sắp xếp theo thứ tự abc với một từ trên mỗi dòng và không có từ nào lặp lại hai lần. Nó có thể là chữ thường hoặc chữ hoa nhưng không trộn lẫn. Vì vậy, danh sách có thể bắt đầu và kết thúc như thế này:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Nguyên âm là a - e - i - o - u - y , 20 chữ cái khác trong bảng chữ cái tiếng Anh là phụ âm.
Từ không phải là từ trong thực tế.
Mã ngắn nhất sẽ thắng.

Lưu ý: Một vài năm trước, tôi tình cờ thấy một chương trình trên một trang web của trường đại học đã làm chính xác điều đó. Hóa ra tên và họ của tôi phù hợp với ràng buộc cvcvc và tôi đã tự mình googling.

Toán học, 72 65 61 byte

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

Để thử nghiệm, tôi khuyên bạn nên thay thế Print@@@bằng ""<>#&/@. Mathicala sau đó sẽ hiển thị một hình thức rút gọn hiển thị một vài từ đầu tiên và vài từ cuối cùng, thay vì mất mãi mãi để in 288.000 dòng.

Giải trình

Cuối cùng tôi đã tìm thấy một cách sử dụng để phân chia chuỗi. :)

Tôi đã bị thu hút bởi khả năng thêm hoặc nhân chuỗi trong một thời gian, nhưng các trường hợp sử dụng thực tế khá hạn chế. Vấn đề chính là cái gì đó như "foo"+"bar"hoặc "foo"*"bar"(và do đó, hình thức ngắn "foo""bar") là hoàn toàn hợp lệ trong Mathematica. Tuy nhiên, nó thực sự không biết phải làm gì với các chuỗi trong các biểu thức số học, vì vậy những điều này vẫn chưa được đánh giá. Mathematica không áp dụng đơn giản hóa áp dụng thường mặc dù. Cụ thể, các chuỗi sẽ được sắp xếp theo thứ tự chính tắc (khá rối trong Mathicala, một khi bạn bắt đầu sắp xếp các chuỗi chứa các chữ cái của các trường hợp khác nhau, chữ số và không phải chữ cái), thường là một công cụ giải quyết, nhưng không thành vấn đề ở đây . Hơn nữa, "abc""abc"sẽ được đơn giản hóa để"abc"^2(đó là một vấn đề khi bạn có các chuỗi lặp lại, nhưng chúng tôi cũng không có vấn đề đó) và một cái gì đó giống như "abc"/"abc"sẽ thực sự hủy bỏ (mà chúng ta thậm chí sẽ sử dụng).

Vì vậy, những gì chúng ta đang cố gắng để chơi golf ở đây. Chúng tôi cần một danh sách các nguyên âm và một danh sách các phụ âm, vì vậy chúng tôi có thể cung cấp cho chúng Tuplesđể tạo ra tất cả các kết hợp có thể. Cách tiếp cận đầu tiên của tôi là giải pháp ngây thơ:

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

Đó là danh sách các phụ âm được mã hóa cứng làm tổn thương một chút. Mathematica có tích Alphabethợp sẵn cho phép tôi tránh nó, nếu tôi có thể loại bỏ các nguyên âm một cách rẻ tiền. Đây là nơi nó trở nên khó khăn mặc dù. Cách đơn giản nhất để loại bỏ các phần tử là Complement, nhưng cuối cùng lại dài hơn, sử dụng một trong các tùy chọn sau:

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

(Lưu ý rằng chúng ta không cần phải áp dụng Characterscho toàn bộ điều này nữa, vì Alphabet[]đưa ra một danh sách các chữ cái, không phải là một chuỗi.)

Vì vậy, hãy thử kinh doanh số học. Nếu chúng ta biểu thị toàn bộ bảng chữ cái dưới dạng sản phẩm của các chữ cái thay vì danh sách, thì chúng ta có thể xóa các chữ cái bằng cách chia đơn giản, do quy tắc hủy. Điều đó tiết kiệm rất nhiều byte vì chúng ta sẽ không cần Complement. Hơn nữa, "a""e""i""o""u""y"thực sự là một byte ngắn hơn Characters@"aeiouy". Vì vậy, chúng tôi làm điều này với:

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

Trường hợp chúng tôi lưu trữ các sản phẩm phụ âm và nguyên âm trong avà b, tương ứng. Điều này hoạt động bằng cách viết một hàm nhân tất cả các đối số của nó ##và chia chúng cho sản phẩm của các nguyên âm. Hàm này được áp dụng cho danh sách bảng chữ cái, chuyển từng chữ cái thành một đối số riêng biệt.

Cho đến nay rất tốt, nhưng bây giờ chúng ta có

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

như là đối số Tuplesvà những thứ đó vẫn là sản phẩm, không phải là danh sách. Thông thường, cách ngắn nhất để khắc phục đó là đặt List@@@phía trước, giúp biến các sản phẩm thành danh sách một lần nữa. Thật không may, thêm 7 byte đó làm cho nó dài hơn cách tiếp cận ngây thơ.

Tuy nhiên, hóa ra Tupleskhông quan tâm đến những người đứng đầu danh sách bên trong. Nếu bạn làm

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

(Có, đối với một không xác định f.) Bạn sẽ nhận được:

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

Giống như bạn đã sử dụng một Listthay vì f. Vì vậy, chúng tôi thực sự có thể vượt qua những sản phẩm đó mà Tuplesvẫn nhận được kết quả đúng. Điều này tiết kiệm 5 byte theo cách tiếp cận ngây thơ bằng cách sử dụng hai chuỗi mã hóa cứng.

Bây giờ "a""e""i""o""u""y"vẫn còn khá khó chịu. Nhưng chờ đã, chúng ta cũng có thể lưu một vài byte ở đây! Các đối số của chức năng của chúng tôi là các chữ cái riêng lẻ. Vì vậy, nếu chúng ta chỉ chọn ra các đối số phù hợp, chúng ta có thể sử dụng lại các đối số đó thay vì các chuỗi ký tự, ngắn hơn cho ba trong số chúng. Chúng tôi muốn lập luận #(viết tắt #1), #5, #9, #15, #21và #25. Nếu chúng ta đặt #ở cuối, thì chúng ta cũng không cần thêm bất kỳ *để nhân chúng lại với nhau, bởi vì (regex) #\d+là một mã thông báo hoàn chỉnh không thể có bất kỳ chữ số nào được thêm vào nó. Do đó, chúng tôi kết thúc với #5#9#15#21#25#, tiết kiệm thêm 4 byte.

Perl, 47 byte

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

Đếm số shebang là một.

Hãy thử trực tuyến!

Python 3 - 110 byte

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

Vui vẻ vòng lặp đơn giản :)

Ruby, 72 71 52 byte

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

Cảm ơn Value Ink cho ý tưởng cơ bản, đã đưa nó xuống tới 60 byte.

05AB1E , 18 16 byte

05AB1E sử dụng mã hóa CP-1252 .

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

Giải trình

ž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

Đối với mục đích thử nghiệm, tôi khuyên bạn nên thay thế žPbằng một vài phụ âm và žOmột vài nguyên âm.

Ví dụ sử dụng 5 phụ âm và 3 nguyên âm

Python 2 , 120 102 94 byte

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

Hãy thử trực tuyến!

Bash thuần túy, 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

Mở rộng nẹp đơn giản.

Hãy thử trực tuyến .

Nếu mỗi mục phải nằm trên một dòng riêng, thì chúng ta có:

Bash tinh khiết, 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 byte

gia tăng chuỗi đẹp :)
6 byte được lưu bởi @Christoph

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

các vòng lặp thông qua tất cả các chuỗi từ bababađến zyzyzvà kiểm tra nếu chúng khớp với mẫu. Chạy với -nr.

MATL , 21 byte

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

Hãy thử trực tuyến! (nhưng đầu ra bị cắt ngắn).

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 byte

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

Không thể để itertoolschiến thắng. Lặp lại dài hơn 1 byte trong Python 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 byte

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

mapM func listxây dựng tất cả các từ bằng cách lấy các ký tự có thể cho chỉ mục i từ danh sách được trả về bởi func (list!!i).

Chỉnh sửa: @xnor tìm thấy 2 byte để lưu và xem xét giải pháp của anh ấy, tôi tìm thấy một byte khác.

Brachylog , 18 byte

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

Hãy thử trực tuyến!

Giải trình

@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 byte

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

Chỉnh sửa

• ETHproductions: -1 byte bằng cách loại bỏ nhóm không liên quan xung quanh toán tử ternary trong forcâu lệnh

Giải trình

Điều này xác định hàm đệ quy 5 độ sâu sử dụng tính chẵn lẻ của độ sâu cuộc gọi của nó để xác định xem có lặp lại nguyên âm hay phụ âm hay không. Trên mỗi lần lặp, nó kiểm tra xem có nên lặp lại hoặc in hay không bằng cách kiểm tra số lần thu hồi còn lại và nối chữ cái của lần lặp hiện tại của nó vào cuối chuỗi 5 ký tự hiện đang được xây dựng theo chiều sâu.

Giải pháp thay thế 89 byte giả sử mã hóa 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)}

Giải pháp thay thế 96 byte trả về toàn bộ đầu ra dưới dạng một chuỗi:

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

Chạy có nguy cơ của riêng bạn. Đối với giải pháp 91 byte, chỉ cần sử dụng f()và cho giải pháp thay thế 97 byte, sử dụng console.log(f()).

C, 201 199 186 184 183 169 163 byte

Làm điều đó khác một chút so với phương pháp đếm cơ bản trước đó:

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

Ung dung:

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

Và được viết theo cách thông thường hơn một chút:

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

Về cơ bản, tôi là các bộ đếm và là chuỗi các chuỗi chứa tất cả các ký tự mà chúng ta nên lặp lại cho mỗi bộ đếm. Thủ thuật là vòng lặp while bên trong : nó được sử dụng để tăng các bộ đếm, bắt đầu từ cái ngoài cùng bên phải. Nếu chúng ta thấy rằng ký tự tiếp theo chúng ta sẽ hiển thị là null char kết thúc, chúng ta khởi động lại bộ đếm về 0 và "carry" sẽ được truyền tới bộ đếm tiếp theo.

Cảm ơn Cristoph!

Perl, 71 byte

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

Hãy thử trực tuyến!

Giải trình

Tôi sẽ thêm nhiều lời giải thích sau.

map{push@{1+/[aeiouy]/},$_}a..z;tạo hai mảng: @1chứa các phụ âm và @2chứa các nguyên âm.
globkhi gọi với các đối số như {a,b}{c,d}trả về tất cả các hoán vị của các phần tử trong dấu ngoặc nhọn.

Befunge, 95 byte

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

Hãy thử trực tuyến! , mặc dù lưu ý rằng đầu ra sẽ bị cắt ngắn.

Đây chỉ là một vòng lặp trong phạm vi từ 0 đến 287999, xuất ra chỉ mục dưới dạng số dựa trên hỗn hợp 20-6-20-6-20, với "chữ số" của số được lấy từ các bảng trên hai dòng cuối cùng.

Perl 6 , 70 byte

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

Giải thích về phần thú vị:

.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

Đoạn mã trước đó chỉ tạo ra danh sách các nguyên âm ( $_) và danh sách các phụ âm ( c), đáng tiếc là dài dòng.

Python 2 , 120 117 byte

Cảm ơn @WheatWizard cho mẹo về tab.

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

Hãy thử trực tuyến!

Không chắc chắn rằng điều này có thể được chơi golf nhiều. Hãy thử cắt ngắn trực tuyến ở 128KB nhưng hiển thị đủ để đưa ra ý tưởng. Một lần chạy cục bộ với mã gỡ lỗi để đếm các từ đã cho tổng cộng 288000. Chạy trong khoảng 45 giây nếu có ai muốn kiểm tra.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Phiên bản không tuân thủ và do đó không cạnh tranh (in ra các mảng lồng nhau thay vì định dạng đã chỉ định) cho 110 byte:

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 byte

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

Mất một ít thời gian để có bất kỳ đầu ra. Rất kém hiệu quả. Làm công việc.

xeger , 49 byte

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

Đưa ra một biểu thức chính quy, xeger chỉ đơn giản tạo ra tất cả các chuỗi khớp. Để không giết trình duyệt, nó sẽ tạm dừng mỗi 1000 đầu ra và bạn cần nhấp để tiếp tục, nhưng cuối cùng nó sẽ đến đó.

Đây là phiên bản 23 byte với một lỗi đã được ^sửa:

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

Đây là lớp nhân vật "tất cả-chữ thường phụ âm ASCII" [:c]với yloại trừ ^y, và "tất cả-chữ thường nguyên âm ASCII" [:v:]với ythêm.

JavaScript (Firefox 30-57), 82 byte

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

Trả về một chuỗi các chuỗi. Phiên bản rất nhanh cho 102 101 (1 byte nhờ các byte @ETHproductions):

_=>[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 byte

Đã lưu 2 byte nhờ Martin Ender và 1 byte nhờ kaine

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

Hãy thử trực tuyến! (Lưu ý rằng đầu ra bị cắt trên TIO)

Giải trình

"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

Xếp chồng, không biên dịch, 51 byte

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

Khá đơn giản. Hãy thử nó ở đây!

Perl, 63 59 54 byte

$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

Đang thử chơi golf Perl để thay đổi.
EDIT: Có vẻ như tôi vẫn còn nhiều điều phải học ... :)

Scala, 87 86 byte

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 byte

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

Đây là lần đầu tiên tôi chơi golf mã, vì vậy tôi hoan nghênh mọi đề xuất để cắt giảm hơn nữa. Cho đến nay, tất cả đều là tiêu chuẩn R; điều duy nhất có thể khó khăn ở đây là paste0 tái chế các đối số của nó theo chiều dài của đối số dài nhất.

Chỉnh sửa: sử dụng thủ thuật gán từ rturnbull, thay thế sapply(x,length)bằng lengths.

R, 111 98 byte

Được thêm vào ydưới dạng nguyên âm và đánh gôn 13 byte, nhờ @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="")

Chúng tôi sử dụng expand.gridđể tạo ra tất cả các kết hợp có thể có Vvà Ctrong một ma trận, mà chúng tôi xác định từ biến đặt trước letters(bảng chữ cái). Chúng tôi đảo ngược các kết hợp (như mặc định là biến đầu tiên xoay nhanh nhất) để đảm bảo thứ tự chữ cái. Sau đó, chúng tôi lặp lại qua từng hàng của ma trận, in từng chữ cái thành thiết bị xuất chuẩn. Chúng tôi sử dụng fillđối số để catđảm bảo rằng mỗi từ bắt đầu trên một dòng mới.

Clojure, 101 byte

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

Không thú vị lắm ...

Ruby, 65 61 byte

Cách tiếp cận hoàn toàn khác nhau:

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

Những điều mới tôi đã học ngày hôm nay: chức năng sản phẩm Array #

C 361 byte

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

Phiên bản bị đánh cắp:

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

Phải có một số cách để rút ngắn điều này chắc chắn.

Giải trình

• Lưu trữ các giá trị nguyên của a, e, i, o, u, y trong một mảng số,
• Được lưu trữ tất cả các bảng chữ cái trong mảng, nếu đó là một nguyên âm, thay thế nó bằng một phụ âm, do đó, có các giá trị phụ âm trùng lặp trong mảng,
• Đã xóa các giá trị phụ âm trùng lặp,
• In tất cả các kết hợp cvcvc.