Göreviniz, her beş harften oluşan kelimelerin okunabilir bir listesini çıkartabilecek bir program yazmak.

ünsüz - ünlü - ünsüz - ünlü - ünsüz

Çıktı, her satırda bir sözcük olacak şekilde alfabetik olarak sıralanmalı ve iki kez tekrar edilmemelidir. Küçük veya büyük harf olabilir, ancak karıştırılamaz. Böylece liste şöyle başlayıp bitebilir:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Ünlüler a - e - i - o - u - y , diğer 20 İngilizce-alfabesi harfleri ünsüzlerdir.
Kelimelerin gerçek sözlük kelimeleri olması gerekmez.
En kısa kod kazanır.

Not: Birkaç yıl önce bir üniversite web sitesinde tam olarak bunu yapan bir programa rastladım. İlk adımı ve soyadımın, cvcvc kısıtlamasına uyduğu ortaya çıktı ve kendimi googling yapıyordum.

Mathematica, 72 65 61 bayt

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

Test için Print@@@ile değiştirilmesini öneririz ""<>#&/@. Mathematica, sonsuza kadar 288.000 satır yazdırmak yerine, ilk birkaç ve son birkaç kelimeyi gösteren kesik bir form gösterecektir.

açıklama

Sonunda dizeleri bölmek için bir kullanım buldum. :)

Bir süre dizeleri ekleme veya çarpma olasılığı ilgimi çekti, ancak gerçek kullanım durumları oldukça sınırlı. Asıl nokta, Mathematica'da "foo"+"bar"veya benzeri bir şeyin "foo"*"bar"(ve dolayısıyla kısa formun "foo""bar") tamamen geçerli olduğudur. Ancak, aritmetik ifadelerdeki dizelerle ne yapılacağını tam olarak bilmiyor, bu yüzden bu şeyler değerlenmeden kalıyor. Mathematica , genel olarak uygulanabilir basitleştirmeler uygular. Özellikle, dizgiler kanonik düzende sıralanacaktır (bunlar Mathematica'da oldukça karışık, çeşitli durumlarda harfleri, rakamları ve harf olmayan harfleri içeren dizeleri sıralamaya başladığınızda), bunlar genellikle bir sorun kırıcıdır, ancak burada önemli değildir . Ayrıca, "abc""abc"basitleştirilecektir"abc"^2(Bu, tekrarlanan dizeleriniz olduğunda bir problemdir, fakat biz de buna sahip değiliz) ve benzer bir şey "abc"/"abc"aslında iptal eder (hatta biz onu kullanacağız).

Öyleyse burada ne golf oynamaya çalışıyoruz. Ünlüler listesine ve ünsüzler listesine ihtiyacımız var, bu yüzden Tuplesolası tüm kombinasyonları oluşturmak için onları besleyebiliriz . İlk yaklaşımım saf çözümdü:

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

Bu kodlanmış ünsüzlerin listesi biraz acıtıyor. AlphabetÜnlüleri ucuz bir şekilde çıkarabilseydim, Mathematica'nın kendimden sakınmama izin verecek bir yeri var. Burası zorlaştığı yer. Öğeleri kaldırmanın en basit yolu Complement, aşağıdaki seçeneklerden birini kullanarak daha uzun olur;

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

(Artık Charactersher şeye başvurmamız gerekmediğine dikkat edin, çünkü Alphabet[]bir dize değil, bir mektup listesi verir.)

Öyleyse şu aritmetik işi deneyelim. Alfabenin tamamını liste yerine bir harf ürünü olarak temsil edersek, iptal kuralı nedeniyle harfleri basit bir şekilde kaldırabiliriz. Bu çok fazla bayt kazandırır, çünkü ihtiyacımız olmayacak Complement. Ayrıca, "a""e""i""o""u""y"aslında ondan daha kısa bir bayttır Characters@"aeiouy". Bu yüzden şunu yapıyoruz:

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

Ünsüz ve ünlü ürünleri sırasıyla ave içinde depoladığımız yer b. Bu, tüm argümanlarını çarpan ##ve ünlülerin çarpımına ayıran bir işlev yazarak çalışır . Bu işlev, her harfi ayrı bir argüman olarak ileten alfabe listesine uygulanır .

Şimdiye kadar çok iyi, ama şimdi biz var

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

argüman olarak Tuplesve bu şeyler hala ürün, listeler değil. Normalde, düzeltmek için en kısa yol List@@@, bir öne koyar , bu da ürünleri tekrar listelerine dönüştürür. Ne yazık ki, bu 7 baytı eklemek, naif yaklaşımdan daha uzun sürüyor.

Ancak, Tuplesiç listelerin kafalarını hiç umursamadığı ortaya çıkıyor . Yaparsan

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

(Evet, tanımsız bir şey için f.)

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

Sanki Listyerine kullanmış gibisin f. Bu yüzden aslında bu ürünleri doğrudan geçip Tuplesdoğru sonucu alabiliyoruz . Bu, iki sabit kodlanmış dizgiyi kullanarak naif yaklaşımdan 5 bayt kazandırır.

Şimdi "a""e""i""o""u""y"hala oldukça can sıkıcı bir durum. Ama bekle, biz de birkaç byte tasarruf edebiliriz! Bizim fonksiyonumuzun argümanları bireysel harflerdir. Dolayısıyla, doğru argümanları seçersek, üçe daha kısa olan dizgelerin tam anlamıyla yerine tekrar kullanabilirsiniz. Biz argümanları istiyoruz #(kısaltılmışı #1), #5, #9, #15, #21ve #25. Biz koyarsanız #sonunda, o zaman biz de herhangi eklemek gerekmez *(regex), çünkü onları bir arada çoğalmaya #\d+kendisine eklenmiş olmayan rakamı olamaz tam bir belirteç olduğunu. Bu nedenle #5#9#15#21#25#, başka bir 4 byte tasarruf yaparak son buluruz .

Perl, 47 bayt

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

Shebang'ı bir olarak sayıyorum.

Çevrimiçi deneyin!

Python 3 - 110 bayt

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

Basit döngü eğlenceli :)

Ruby, 72 71 52 bayt

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

60 fikire indiren temel fikir için Value Ink sayesinde.

05AB1E , 18 16 bayt

05AB1E , CP-1252 kodlamasını kullanır .

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

açıklama

ž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

Test amacıyla žPbirkaç ünsüz ve žObirkaç sesli harfle değiştirmenizi tavsiye ederim .

5 ünsüz ve 3 sesli harf kullanarak örnek

Python 2 , 120 102 94 bayt

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

Çevrimiçi deneyin!

Saf 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

Basit ayraç genişletme.

Çevrimiçi deneyin .

Her öğe kendi satırında olmalı, biz var:

Saf 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 bayt

güzel dize artışı :)
@Christoph tarafından kaydedilen 6 bayt

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

tüm dizeleri ile döngüler bababaiçin zyzyzve testler eğer kalıpla eşleşen. İle koş -nr.

MATL , 21 bayt

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

Çevrimiçi deneyin! (ancak çıktı kesildi).

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 bayt

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

Kazanmama izin itertoolsveremem. Yinelemeli Python 2'de 1 bayt daha uzundur.

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

Haskell, 54 51 bayt

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

mapM func listi kelimesi tarafından döndürülen listedeki olası karakterleri alarak tüm sözcükleri oluşturur func (list!!i).

Düzenleme: @xnor kaydetmek ve onun çözümüne bakarak 2 bayt bulundu, başka bir tane buldum.

Brachylog , 18 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Düzenlemeler

• ETHproductions: -1 in üçlü operatör etrafında yabancı grubunu kaldırarak bayt foraçıklamada

açıklama

Bu, sesli harfleri veya ünsüzleri yinelemeyi belirlemek için arama derinliğinin eşliğini kullanan 5 derinlemesine bir özyinelemeli işlevi tanımlar. Her yinelemede, kalan yinelemelerin miktarını kontrol ederek tekrarlanıp yazdırılmayacağını kontrol eder ve mevcut yinelemenin harfini, şu anda derinlikli olarak inşa edilen 5 karakter dizesinin sonuna kadar birleştirir.

ISO8859-1 kodlamasını varsayarak alternatif 89 bayt çözüm:

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

Çıktının tamamını tek bir dizge olarak döndüren alternatif 96 baytlık çözüm:

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

Kendi sorumluluğunuzdadır koşun. 91 baytlık çözüm için, sadece kullanın f()ve 97 baytlık alternatif için kullanın console.log(f()).

C, 201 199 186 184 183 169 163 bayt

Önceki temel sayma yönteminden biraz farklı yapmak:

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

Ve biraz daha geleneksel bir şekilde yazılmış:

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

Temel olarak, ben sayaçlar vardır ve s her sayaç için, yineleme gereken her yerinde karakter içeren dizeler dizisi. İşin püf noktası iç süre döngüsüdür: en sağdakinden başlayarak sayaçları artırmak için kullanılır. Göstermemiz gereken bir sonraki karakterin biten boş karakter olduğunu görürsek, sayacı sıfıra yeniden başlatırız ve "carry" bir sonraki sayaca geçirilir.

Teşekkürler Cristoph!

Perl, 71 bayt

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

Çevrimiçi deneyin!

açıklama

Daha sonra daha fazla açıklama ekleyeceğim.

map{push@{1+/[aeiouy]/},$_}a..z;iki dizi oluşturur: @1ünsüzleri ve @2ünlüleri içerir.
globgibi argümanlarla {a,b}{c,d}çağrıldığında parantez içindeki öğelerin tüm permütasyonlarını döndürür.

Befunge, 95 bayt

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

Çevrimiçi deneyin! , bununla birlikte, çıktının kesileceğini unutmayın.

Bu sadece 0 ila 287999 aralığındaki bir döngüdür, endeksi karma bir sayı olarak 20-6-20-6-20 arası bir sayı olarak verir, son iki satırdaki tablolardan alınan sayıların "rakamları" ile.

Perl 6 , 70 bayt

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

İlginç kısmın açıklaması:

.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

Ondan önceki kod sadece ünlüler ( $_) ve ünsüzlerin ( c) ünsüzlemeli bir listesini içeren ünsüzlerin listesini oluşturur .

Python 2 , 120 117 bayt

Sekmeler ipucu için @WheatWizard sayesinde.

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

Çevrimiçi deneyin!

Bunun çok fazla golf oynayabileceğinden emin değilim. Çevrimiçi deneyin 128KB'de kesiliyor ancak bir fikir verebilecek kadarını gösteriyor. Kelimeleri saymak için hata ayıklama koduyla yerel bir çalıştırma toplamı 288000 verdi. Biri test etmek istiyorsa yaklaşık 45 saniye içinde çalışır.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

110 bayt için uyumlu olmayan ve bu nedenle rekabetçi olmayan sürüm (belirtilen format yerine iç içe dizileri yazdırır):

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 Bayt

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

Herhangi bir çıktının olması biraz zaman alır. Çok verimsiz. İşi yapar.

xeger , 49 bayt

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

Düzenli bir ifade verildiğinde, xeger tüm eşleşen dizeleri oluşturur. Tarayıcıyı öldürmemek için her 1000 çıkışı duraklatır ve devam etmek için tıklamanız gerekir, ancak sonuçta oraya ulaşır.

İşte ^düzeltilen bir hatayı içeren 23 baytlık bir sürüm :

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

Bu karakter sınıfları "küçük harflerden ASCII sessizler" dir [:c]ile ydışlanan ^yve "küçük harflerden ASCII ünlüler" [:v:]ile yekledi.

JavaScript (Firefox 30-57), 82 bayt

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

Bir dizi dizeyi döndürür. 102 101 için çok hızlı versiyon (@ETHproductions sayesinde 1 byte) byte:

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

Martin Ender sayesinde 2 bayt, kaine sayesinde 1 bayt kaydedildi

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

Çevrimiçi deneyin! (Çıkışın TIO'da kesildiğini unutmayın)

açıklama

"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

Yığılmış, rekabet etmeyen, 51 bayt

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

Oldukça basit. Burada dene!

Perl, 63 59 54 bayt

$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

Değişim için Perl golfünü denemek.
EDIT: Hala öğrenecek çok şeyim var gibi görünüyor ... :)

Scala, 87 86 bayt

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 bayt

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

Bu benim ilk golf koduma gitmem, bu yüzden daha fazla kesmek için herhangi bir öneriniz var. Şimdiye kadar hepsi oldukça standart R; Buradaki tek olası şey, paste0'ün argümanlarını en uzun olana kadar geri dönüştürmesidir.

Düzenleme: rturnbull gelen ikinci el atama hile, yerini sapply(x,length)ile lengths.

R, 111 98 bayt

yÜnlü olarak eklenmiş ve @Patrick B sayesinde 13 byte golf atmıştır.

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

Önceden belirlenmiş değişkenden (alfabe) tanımladığımız expand.gridtüm olası kombinasyonları Vve Cmatrislerde üretmek için kullanırız letters. Alfabetik sıralamayı sağlamak için kombinasyonları (en hızlı döndüren ilk değişkenin varsayılanı olduğu gibi) tersine çeviriyoruz. Daha sonra matrisin her bir satırını yineleriz, her harfi stdout'a yazdırırız. Her bir kelimenin yeni bir satırda başlamasını sağlamak için fillargümanı kullanırız cat.

Clojure, 101 bayt

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

Bu heyecan verici değil ...

Ruby, 65 61 bayt

Tamamen farklı bir yaklaşım:

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

Bugün öğrendiğim yeni şeyler: Array # product işlevi

C 361 bayt

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

Ungolfed versiyonu:

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

Bunu kesinlikle kısaltmanın bir yolu olmalı.

açıklama

• A, e, i, o, u, y tam sayı değerlerini sayısal bir dizide saklar,
• Dizideki tüm alfabeleri sakladı, eğer bir sesliyse, onu bir ünsüzle değiştirdi, bu yüzden dizide yinelenen ünsüz değerleri vardı,
• Kaldırılan yinelenen ünsüz değerleri,
• Tüm kombinasyonlar cvcvc yazdırıldı.