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

согласный - гласный - согласный - гласный - согласный

Вывод должен быть отсортирован в алфавитном порядке по одному слову в строке, и слова не должны повторяться дважды. Это может быть строчная или прописная буква, но не смешанная. Таким образом, список может начинаться и заканчиваться так:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Гласные - е - я - о - у - у , остальные 20 Английский-алфавит буквы согласные. Слова не должны быть фактическими словарными словами. Самый короткий код выигрывает.

Примечание: несколько лет назад я наткнулся на программу на веб-сайте университета, которая сделала именно это. Оказывается, мои имя и фамилия соответствуют ограничениям cvcvc, и я сам гуглил.

Mathematica, 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
");

перебирает все строки из bababato 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

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

Ungolfed:

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Когда call с аргументами like {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 для разнообразия.
РЕДАКТИРОВАТЬ: Похоже, я еще многому научиться ... :)

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Благодаря @Patrick B. добавлен в качестве гласного и содержит 13 байт.

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(алфавит). Мы инвертируем комбинации (поскольку по умолчанию первая переменная вращается быстрее всего), чтобы обеспечить алфавитный порядок. Затем мы перебираем каждую строку матрицы, печатая каждую букву в стандартный вывод. Мы используем 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.