Ваше завдання - написати програму, яка виводить читабельний список кожні п'ять літер зі структурою:

приголосний - голосний - приголосний - голосний - приголосний

Вихід повинен бути відсортований в алфавітному порядку з одним словом на рядок і жодних слів, повторених двічі. Він може бути малим або великим, але не змішаним. Отже список може починатися і закінчуватися так:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Голосні - a - e - i - o - u - y , інші 20 букв англійського алфавіту - приголосні.
Слова не повинні бути власне словниковими словами.
Найкоротший код виграє.

Примітка. Кілька років тому я натрапив на програму на веб-сайті університету, яка саме так і зробила. Виявляється, моє ім’я та прізвище відповідають обмеженням cvcvc, і я гуглив себе.

Математика, 72 65 61 байт

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

Для тестування рекомендую замінити Print@@@на ""<>#&/@. Потім Mathematica відобразить усічену форму, де відображаються перші кілька та останніх слів, замість того, щоб назавжди надрукувати 288 000 рядків.

Пояснення

Нарешті я знайшов застосування для поділу рядків. :)

Мене інтригує можливість додавання або множення рядків на деякий час, але фактичні випадки використання досить обмежені. Основний момент полягає в тому, що щось подібне "foo"+"bar"або "foo"*"bar"(а отже, коротка форма "foo""bar") цілком справедливо в Mathematica. Однак насправді не відомо, що робити з рядками в арифметичних виразах, тому ці речі залишаються неоціненими. Mathematica дійсно застосовується , як правило , застосовуються спрощення , хоча. Зокрема, рядки будуть відсортовані в канонічний порядок (що досить заплутано в Mathematica, як тільки ви почнете сортувати рядки, що містять букви різних справ, цифр та не літер), що часто є порушником, але тут не має значення. . Крім того, "abc""abc"буде спрощено до"abc"^2(що є проблемою, коли ви повторюєте рядки, але у нас цього також немає), і щось подібне "abc"/"abc"насправді скасує (що ми навіть будемо використовувати).

То що ми намагаємося тут займатися гольфом. Нам потрібен список голосних і список приголосних, щоб ми могли їх подавати, Tuplesщоб генерувати всі можливі комбінації. Першим моїм підходом було наївне рішення:

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

Цей твердо кодований список приголосних трохи шкодить. У Mathematica є Alphabetвбудований модуль, який дозволив би мені уникнути цього, якби я міг дешевими способами видалити голосні звуки. Тут це стає складним, хоча. Найпростіший спосіб видалити елементи Complement, але це закінчується довше, використовуючи один із наступних варіантів:

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

(Зверніть увагу, що нам більше не потрібно застосовуватись Charactersдо всієї справи, тому що Alphabet[]дає список букв, а не рядка.)

Тож спробуємо цей арифметичний бізнес. Якщо ми представляємо весь алфавіт як добуток літер замість списку, то ми можемо видалити літери простим поділом, завдяки правилу скасування. Це економить багато байтів, тому що нам це не потрібно Complement. Крім того, "a""e""i""o""u""y"насправді байт коротший, ніж Characters@"aeiouy". Тож ми робимо це за допомогою:

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

Де ми зберігання згодної і гласною продуктів в aі b, відповідно. Це працює, записуючи функцію, яка множує всі її аргументи ##і ділить їх на добуток голосних. Ця функція застосовується до списку алфавіту, який передає кожну букву окремим аргументом.

Поки що добре, але зараз у нас є

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

як аргумент Tuples, і ті речі все ще є продуктами, а не списками. Зазвичай, це найкоротший спосіб виправити те, що ставиться List@@@на фронті, що знову перетворює товари в списки. На жаль, додавання цих 7 байтів робить це довше, ніж наївний підхід.

Однак, виявляється, це Tuplesзовсім не хвилює керівників внутрішніх списків. Якщо ти зробиш

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

(Так, для невизначеного f.) Ви отримаєте:

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

Так само, як якщо б ви використовували Listзамість цього f. Тож ми можемо реально передавати ці продукти прямо Tuplesта все-таки отримати правильний результат. Це економить 5 байт над наївним підходом, використовуючи дві твердо кодовані рядки.

Зараз "a""e""i""o""u""y"це все ще досить дратує. Але зачекайте, і тут ми можемо зберегти кілька байт! Аргументами нашої функції є окремі букви. Тож якщо ми просто підберемо правильні аргументи, ми можемо використати їх замість рядкових літералів, що для трьох з них коротше. Ми хочемо , щоб аргументи #(скорочено #1) #5, #9, #15, #21і #25. Якщо поставити #в кінці, то нам також не потрібно додавати жодних *для їх множення разом, тому що (регулярний вираз) #\d+- це повна лексема, до якої не може бути додано жодної нецифрової цифри. Отже, ми закінчуємо #5#9#15#21#25#, зберігаючи ще 4 байти.

Perl, 47 байт

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

Порахувавши шебанг як один.

Спробуйте в Інтернеті!

Python 3 - 110 байт

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

Прямо веселі петлі :)

Рубі, 72 71 52 байт

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

Завдяки Value Ink за основну ідею, яка знизила це до 60 байт.

05AB1E , 18 16 байт

05AB1E використовує кодування CP-1252 .

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

Пояснення

ž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

Для цілей тестування рекомендую замінити žPкількома приголосними та žOкількома голосними.

Приклад з використанням 5 приголосних і 3 голосних

Python 2 , 120 102 94 байт

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

Спробуйте в Інтернеті!

Чистий Баш, 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

Пряме розширення брекетів.

Спробуйте в Інтернеті .

Якщо кожен елемент повинен бути у своєму рядку, ми маємо:

Чистий Баш, 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 байт

Приріст досить рядка :)
6 байт збережено @Christoph

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

проходить цикл через усі рядки від bababaдо zyzyzта тестує, чи вони відповідають шаблону. Бігайте з -nr.

MATL , 21 байт

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

Спробуйте в Інтернеті! (але результат обрізаний).

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

Пітон, 92 байти

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

Не можна дозволити itertoolsвиграти. Ітеративний на 1 байт довший у 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 байт

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

mapM func listбудує всі слова, беручи можливі символи для індексу i зі списку, що повертається func (list!!i).

Редагувати: @xnor знайшов 2 байти, щоб зберегти, і переглянувши його рішення, я знайшов ще один.

Брахілог , 18 байт

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

Спробуйте в Інтернеті!

Пояснення

@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 байт

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

Правки

• ETHproductions: -1 байти, видаляючи сторонні групи навколо потрійного оператора в forзаяві

Пояснення

Це визначає 5-глибоку рекурсивну функцію, яка використовує паритет глибини дзвінка, щоб визначити, чи слід повторювати голосні чи приголосні. На кожній ітерації він перевіряє, чи слід повторювати чи надрукувати, перевіряючи кількість рекурсій, що залишилися, і з'єднує букву його поточної ітерації до кінця рядка з 5 символів, який наразі будується першою глибиною.

Альтернативно 89-байтне рішення, припускаючи кодування 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)}

Альтернативне 96-байтне рішення, яке повертає весь результат у вигляді однієї рядки:

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

Бігайте на свій страх і ризик. Для рішення, що має 91 байт, просто використовуйте, f()а для альтернативи - 97 байт console.log(f()).

C, 201 199 186 184 183 169 163 байт

Робити це трохи інакше, ніж попередній основний метод підрахунку:

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

Безголовки:

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

І написано трохи більш звичайним чином:

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

В основному, я - лічильники, і s масив рядків, що містить усі символи, над якими ми повинні повторити, для кожного лічильника. Хитрість - внутрішній час циклу: він використовується для збільшення лічильників, починаючи з самого правого одного. Якщо ми бачимо, що наступним символом, який ми повинні відобразити, є закінчується нульовий знак, ми перезапускаємо лічильник до нуля, а "переносити" буде передано на наступний лічильник.

Дякую Крістофе!

Perl, 71 байт

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

Спробуйте в Інтернеті!

Пояснення

Пізніше пояснення додам.

map{push@{1+/[aeiouy]/},$_}a..z;створює два масиви: @1містить приголосні та @2містить голосні.
globпри виклику з аргументами типу {a,b}{c,d}повертає всі перестановки елементів в дужках.

Befunge, 95 байт

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

Спробуйте в Інтернеті! , хоча зауважте, що вихід буде усічений.

Це лише цикл у діапазоні від 0 до 287999, виводить індекс у вигляді змішаного на основі числа 20-6-20-6-20 із "цифрами" числа, отриманого з таблиць у двох останніх рядках.

Perl 6 , 70 байт

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

Пояснення цікавої частини:

.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

Код до цього просто генерує список голосних ( $_) та список приголосних ( c), який, на жаль, є багатослівним.

Python 2 , 120 117 байт

Дякуємо @WheatWizard за підказку вкладок.

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

Спробуйте в Інтернеті!

Не впевнений, що в цьому можна багато пограти в гольф. Спробуйте це онлайн-скорочення на 128 КБ, але показує достатньо, щоб дати ідею. Місцевий пробіг з кодом налагодження для підрахунку слів дав загальну суму 288000. Запускається приблизно за 45 секунд, якщо хтось хоче перевірити.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Невідповідна і тому неконкурентна версія (виводить вкладені масиви замість заданого формату) на 110 байт:

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 байт

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

Знадобиться небагато часу, щоб мати будь-який вихід. Дуже неефективно. Робить роботу.

xeger , 49 байт

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

Даючи регулярний вираз, xeger просто генерує всі відповідні рядки. Щоб не вбити браузер, він робить паузу на кожні 1000 виходів і вам потрібно натиснути, щоб продовжити, але він з часом з’явиться.

Ось 23-байтна версія з виправленою помилкою ^:

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

Це класи символів "усі малі регістри ASCII приголосних" [:c]з yвиключеними ^y, і "всі голосні звуки ASCII [:v:]з малі регістри" з yдоданими.

JavaScript (Firefox 30-57), 82 байти

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

Повертає масив рядків. Дуже швидка версія для 102 101 (1 байт завдяки @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 байт

Збережено 2 байти завдяки Мартіну Ендеру та 1 байт завдяки каїну

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

Спробуйте в Інтернеті! (Зверніть увагу, що вихід вимикається на TIO)

Пояснення

"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

Складений, неконкурентний, 51 байт

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

Досить просто. Спробуйте тут!

Perl, 63 59 54 байт

$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

Спробуйте Perl golf для зміни.
EDIT: Схоже, у мене ще багато чому навчитися ... :)

Scala, 87 86 байт

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 байт

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

Це моя перша поїздка в гольф з кодом, тому я вітаю будь-які пропозиції, щоб подальше її рубати. Поки це все досить стандартне R; Єдине, можливо, хитрість тут полягає в тому, що paste0 переробляє свої аргументи на довжину найдовшого.

Редагувати: використаний трюк призначення від rturnbull, замінений sapply(x,length)на lengths.

R, 111 98 байт

Додано y як голосну і зіграє 13 байт, завдяки @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="")

Ми використовуємо expand.gridдля генерації всіх можливих комбінацій матриці Vта Cв матриці, яку ми визначаємо із заданої змінної letters(алфавіту). Ми повертаємо комбінації (оскільки за замовчуванням перша швидка обертається для першої змінної), щоб забезпечити алфавітний порядок. Потім ми повторюємо кожен рядок матриці, друкуючи кожну букву в stdout. Ми використовуємо fillаргумент для того, catщоб кожне слово починалося з нового рядка.

Clojure, 101 байт

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

Не так захоплююче ...

Рубі, 65 61 байт

Зовсім інший підхід:

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

Нові речі, про які я сьогодні дізнався: функція продукту Array #

C 361 байт

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

Негольована версія:

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

Має бути якийсь спосіб, щоб це однозначно скоротити.

Пояснення

• Збережено цілі значення a, e, i, o, u, y у числовому масиві,
• Зберігав усі алфавіти в масиві, якщо це був голосний, заміняв його на приголосний, тому в масиві були дублюючі приголосні значення,
• Вилучені повторювані значення приголосних,
• Надруковано всі комбінації cvcvc.