당신의 임무는 구조와 함께 다섯 글자 단어의 읽을 수있는 목록을 출력하는 프로그램을 작성하는 것입니다 :

자음-모음-자음-모음-자음

출력은 한 줄에 한 단어 씩 사전 순으로 정렬해야하며 두 번 반복되는 단어는 없습니다. 소문자 또는 대문자 일 수 있지만 혼합 할 수는 없습니다. 따라서 목록은 다음과 같이 시작하고 끝날 수 있습니다.

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

모음은 - 전자 - 난 - 오 - 유 - y를 , 다른 20 영어 알파벳 문자는 자음입니다. 단어는 실제 사전 단어 일 필요는 없습니다. 가장 짧은 코드가 승리합니다.

참고 : 몇 년 전에 저는 정확히 그렇게했던 대학 웹 사이트의 프로그램을 우연히 발견했습니다. 내 성명은 cvcvc 제약 조건에 맞으며 나 자신을 인터넷 검색했습니다.

Mathematica, 72 65 61 바이트

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

테스트를 위해로 교체 Print@@@하는 것이 좋습니다 ""<>#&/@. Mathematica는 288,000 줄을 영원히 인쇄하는 대신 처음 몇 단어와 마지막 몇 단어를 보여주는 잘린 형태를 표시합니다.

설명

마침내 문자열을 나누는 용도를 찾았습니다. :)

한동안 문자열을 추가하거나 곱할 가능성에 흥미가 있었지만 실제 사용 사례는 상당히 제한적입니다. 요점은 Mathematica에서 "foo"+"bar"or "foo"*"bar"와 같은 (따라서 짧은 형식 "foo""bar")이 완전히 유효하다는 것입니다. 그러나 실제로는 산술 표현식에서 문자열로 무엇을 해야할지 알지 못하므로 이러한 사항은 평가되지 않습니다. Mathematica 는 일반적으로 적용 가능한 단순화를 적용합니다. 특히 문자열은 정식 순서로 정렬되며 (대문자, 숫자 및 문자가 아닌 문자를 포함하는 문자열을 정렬하기 시작하면 Mathematica에서 상당히 엉망이 됨) 종종 거래를 중단하지만 여기서는 중요하지 않습니다. . 또한 다음과 "abc""abc"같이 단순화됩니다"abc"^2(이것은 문자열을 반복했을 때 문제가되지만 우리는 그것을 가지고 있지 않습니다 "abc"/"abc".)

그래서 우리는 여기서 골프를하려고합니다. 모음 목록과 자음 목록이 필요하므로 Tuples가능한 모든 조합을 생성 하도록 피드 할 수 있습니다 . 첫 번째 접근 방식은 순진한 솔루션이었습니다.

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

하드 코딩 된 자음 목록은 약간 아 hurt니다. 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"여전히 성가신 일입니다. 그러나 여기서도 몇 바이트를 절약 할 수 있습니다! 우리 기능의 주장은 개별 문자입니다. 따라서 올바른 인수를 선택하면 문자열 리터럴 대신 3 개보다 짧은 인수를 재사용 할 수 있습니다. 우리는 인수가 원하는 #(짧은 #1), #5, #9, #15, #21와 #25. #마지막에 넣을 경우 *(정규식) #\d+은 숫자가 아닌 숫자를 추가 할 수없는 완전한 토큰 이기 때문에 곱하기 위해 추가 할 필요가 없습니다 . 따라서 우리는 #5#9#15#21#25#또 다른 4 바이트를 절약 하면서 끝납니다 .

펄, 47 바이트

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

shebang을 하나로 계산합니다.

온라인으로 사용해보십시오!

파이썬 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 개를 사용한 예

파이썬 (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 바이트

예쁜 문자열 증가 :)
@Christoph에 의해 6 바이트 절약

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이길 수 없습니다 . Python 2에서는 반복이 1 바이트 더 깁니다.

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

하스켈, 54 51 바이트

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

mapM func list에서 반환 한 목록에서 색인 i에 가능한 문자를 사용하여 모든 단어를 작성합니다 func (list!!i).

편집 : @xnor는 저장하고 자신의 솔루션을 볼 2 바이트를 찾았습니다. 다른 것을 찾았습니다.

Brachylog , 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

자바 스크립트 (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 : for명령문 에서 삼항 연산자 주변의 불필요한 그룹을 제거하여 -1 바이트

설명

이 기능은 호출 깊이의 패리티를 사용하여 모음 또는 자음을 반복할지 여부를 결정하는 5 심도의 재귀 함수를 정의합니다. 각 반복에서 남은 재귀 양을 확인하여 재귀 또는 인쇄 여부를 확인하고 현재 반복 문자를 현재 깊이 우선으로 구축되는 5 문자열의 끝으로 연결합니다.

ISO8859-1 인코딩을 가정 한 대체 89 바이트 솔루션 :

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의 우리는 각 카운터, 반복되어야하는 동안 모든 문자를 포함하는 문자열의 배열. 트릭은 내부 while 루프입니다. 가장 오른쪽부터 시작하여 카운터를 증가시키는 데 사용됩니다. 표시해야 할 다음 문자가 종료 널 문자 인 경우 카운터를 0으로 다시 시작하면 "캐리"가 다음 카운터로 전파됩니다.

감사합니다 크리스토프!

펄, 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}하면 중괄호 요소의 모든 순열을 반환합니다.

펀칭, 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으로 출력합니다.

펄 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. 이는 유감스럽게도 장황합니다.

파이썬 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

온라인으로 사용해보십시오!

이것이 골프가 될 수 있는지 확실하지 않습니다. 온라인으로 시도하면 128KB에서 잘리지 만 아이디어를 제공하기에 충분합니다. 단어 수를 세는 디버그 코드를 사용한 로컬 실행은 총 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]

펄 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덧붙였다.

자바 스크립트 (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 (@ETHproductions 덕분에 1 바이트) 바이트를 위한 매우 빠른 버전 :

_=>[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 바이트

Martin Ender 덕분에 2 바이트, kaine 덕분에 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

꽤 간단합니다. 여기 사용해보십시오!

펄, 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

변화를 위해 펄 골프를 시도.
편집 : 나는 아직도 배울 것이 많은 것 같습니다 ... :)

스칼라, 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, 143132 바이트

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각 단어가 새 줄에 시작되도록 할 수 있습니다.

클로저, 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 # product 함수

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를 인쇄했습니다.