38

आपका कार्य एक ऐसा प्रोग्राम लिखना है जो संरचना के साथ प्रत्येक पाँच अक्षर शब्दों की एक पठनीय सूची का उत्पादन करेगा:

व्यंजन - स्वर - व्यंजन - स्वर - व्यंजन

आउटपुट को वर्णानुक्रम में एक शब्द प्रति पंक्ति और दो बार दोहराए गए शब्दों के साथ क्रमबद्ध किया जाना चाहिए। यह लोअरकेस या अपरकेस हो सकता है लेकिन मिश्रित नहीं। तो सूची इस तरह शुरू और समाप्त हो सकती है:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz

स्वर एक - ई - आई - ओ - यू - वाई हैं , अन्य 20 अंग्रेजी-वर्णमाला पत्र व्यंजन हैं।
शब्दों को वास्तविक शब्दकोश शब्द नहीं होना चाहिए।
सबसे छोटा कोड जीतता है।

नोट: कुछ साल पहले मैं एक विश्वविद्यालय की वेबसाइट पर एक कार्यक्रम पर ठोकर खाई थी जिसने वास्तव में ऐसा किया था। मेरा पहला और अंतिम नाम निकलता है, जो कि पीवीसी पीवीसी की कसौटी पर फिट बैठता है, और मैं खुद को गुगला रहा हूं।

— विल्क्स
स्रोत

7

मैं यहां दो चीजें देखता हूं। सबसे पहले, इस तरह के शब्दों की एक हास्यास्पद राशि है। आप प्रविष्टियों का परीक्षण करने की अपेक्षा कैसे करते हैं? इसके अलावा, ऐसे कई नाम हैं जो उस बाधा को फिट करते हैं। सबसे पहले जो दिमाग में आता है , वह है जैकब , हालांकि अन्य लुकास जैसे लोग भी फिट होते हैं

— ट्रोजनबीक एक्सिडेंट

9

@TrojanByAccident मुझे विश्वास है कि चुनौती के लिए सभी संभावित मिलान पत्र संयोजन की आवश्यकता है, चाहे वे नाम / अंग्रेजी शब्द हों। "शब्दों के लिए वास्तविक शब्द शब्द होना जरूरी नहीं है।"

— ट्राइकोप्लाक्स

3

@wilks प्रासंगिक मेटा पोस्ट - इस SE समुदाय में सख्त i / o स्वरूपों की सराहना नहीं की जाती है। यह चुनौती cvcvc शब्द बनाने पर ध्यान केंद्रित कर रही है, शब्दों के बीच newlines नहीं डाल रही है, नहीं?

— जुंगह्वान मिन

1

@JungHwanMin लिंक के लिए धन्यवाद, पहली बार यहाँ और मुझे इस बारे में पता नहीं था। मैंने इसे सभी cvcvc शब्दों की एक पठनीय और वर्णमाला सूची के रूप में देखा। इसलिए मैं मानता हूं कि ऊपरी या निचला हिस्सा वास्तव में मायने नहीं रखता है, लेकिन मुझे यह भी लगता है कि एक बहुत लंबी स्ट्रिंग या, कुछ नेस्टेड सरणियों का कहना है, जबकि तकनीकी रूप से मान्य एक महान जवाब नहीं होगा।

— १५

2

इस प्रश्न के कुछ उत्कीर्ण जवाबों को चलाने के बाद, वे स्पष्ट रूप से "अपनी लाइन पर प्रत्येक शब्द के साथ आउटपुट वृद्धिशील होना चाहिए" का अनुपालन नहीं करते हैं। क्या इस आवश्यकता में ढील दी गई है और यदि आप इसे प्रतिबिंबित करने के लिए प्रश्न को संपादित कर सकते हैं? यदि मेरा उत्तर प्रारूप द्वारा प्रतिबंधित नहीं किया गया था, तो मुझे लगता है कि मैं काफी कुछ बाइट्स खो सकता हूं।

— एलपेड्रो

28

गणितज्ञ, 72 65 61 बाइट्स

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

परीक्षण के लिए, मैं इसके Print@@@साथ प्रतिस्थापित करने की सलाह देता हूं ""<>#&/@। गणितज्ञ तब 288,000 लाइनों को प्रिंट करने के लिए हमेशा के लिए लेने के बजाय पहले कुछ और अंतिम कुछ शब्दों को दिखाते हुए एक छोटा रूप प्रदर्शित करेगा।

व्याख्या

मुझे आखिरकार स्ट्रिंग्स को विभाजित करने के लिए एक उपयोग मिला। :)

मैं कुछ समय के लिए तार जोड़ने या गुणा करने की संभावना से अंतर्ग्रही हो गया हूं, लेकिन वास्तविक उपयोग के मामले काफी सीमित हैं। मुख्य बिंदु यह है कि कुछ ऐसा ( "foo"+"bar"या "foo"*"bar"परिणामस्वरूप, संक्षिप्त रूप "foo""bar") पूरी तरह से गणितज्ञ में मान्य है। हालाँकि, यह वास्तव में पता नहीं है कि अंकगणितीय अभिव्यक्तियों में तार का क्या करना है, इसलिए ये चीजें अविकसित रह जाती हैं। गणितज्ञ आमतौर पर लागू होने वाले सरलीकरणों को लागू करता है । विशेष रूप से, स्ट्रिंग्स को कैनोनिकल ऑर्डर में सॉर्ट किया जाएगा (जो कि मैथमेटिका में काफी गड़बड़ है, एक बार जब आप विभिन्न मामलों के अक्षरों, अंकों और गैर-अक्षरों वाले स्ट्रिंग्स को सॉर्ट करना शुरू कर देते हैं), जो अक्सर एक डीलब्रेकर होता है, लेकिन यहां कोई फर्क नहीं पड़ता । इसके अलावा, "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। यदि हम #अंत में रखते हैं, तो हमें *उन्हें एक साथ जोड़ने के लिए कोई भी जोड़ने की आवश्यकता नहीं है , क्योंकि (regex) #\d+एक पूर्ण टोकन है, जिसके लिए कोई गैर-अंक जोड़ा नहीं जा सकता है। इसलिए हम #5#9#15#21#25#एक और 4 बाइट को बचाते हुए समाप्त होते हैं ।

— मार्टिन एंडर
स्रोत

11

स्पष्टीकरण पढ़ता है। तो ... मूल रूप से जादू।

— टैली

मैं आपकी Tuplesचाल से हैरान और प्रभावित हूँ । यह पूरी तरह से अनिर्दिष्ट है, है ना? और अप्रत्याशित दिया कैसे दो इनपुट फार्म Tuples[list,n]के साथ सौदा listनहीं होने List(कम से कम मेरे लिए) सिर!

— एक सिमंस

@ASimmons ऑब्जेक्ट सूची में सिर की आवश्यकता नहीं है List। द्वारा उत्पन्न सरणियों में प्रत्येक स्तर पर Tuplesसिर सूची के प्रमुख के समान होगा ।

— 21

1

@ngenisis मुझे लगता है कि शब्दांकन बहुत भ्रामक है। क्योंकि यह स्पष्ट नहीं है कि यह कई सूचियों का उपयोग करते समय बाहरी सूची को संदर्भित करता है । दरअसल Tuples[f[{1,2}, {3,4}]]देता है {f[1, 3], f[1, 4], f[2, 3], f[2, 4]}बजाय। यह प्रलेखित नहीं है कि भीतर का सिर पूरी तरह से अनदेखा है।

— मार्टिन एंडर

@ साइमन सी.सी. ^

— मार्टिन एंडर

16

पर्ल, 47 बाइट्स

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

एक के रूप में शेबंग की गिनती।

इसे ऑनलाइन आज़माएं!

— Primo
स्रोत

2

यह अच्छा है, अच्छा किया! कोई भी कारण जो आप उपयोग नहीं कर रहे हैं say?

— दादा

धन्यवाद। मैं असहमत हूं कि -M5.01'मुक्त' होना चाहिए।

— प्रिमो

1

मुझे आपकी राय पसंद है -M5.010। और गोल्फ में intersting भाग को बदलने के लिए नहीं है printके साथ say...

— दादा

एक freebie -E(और बाद में say) नहीं है ?

— ज़ैद

@Zaid देखें प्राइमो की पहली टिप्पणी

— दादा

11

पायथन 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))

सीधा लूपिंग मज़ा :)

— Carra
स्रोत

हमारे विचार समान हैं लेकिन आपने मुझे पायथन 3 के साथ 10 से हराया है!

— एलपेड्रो

मैं बस इस दृष्टिकोण का उपयोग करते हुए एक python2 समकक्ष पोस्ट करने वाला था। बहुत धीमी गति से, आप के बजाय एक वोट।

— क्रिस एच

8

रूबी, 72 71 52 बाइट्स

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

मूल विचार के लिए मूल्य स्याही के लिए धन्यवाद, जिसने 60 बाइट्स को नीचे लाया।

— जीबी
स्रोत

1

यह 5-अक्षर वाले शब्दों की सूची तैयार करने और उपयोग करने के लिए कम है grep। यदि आप एक श्रेणी उत्पन्न करते हैं जो लोअर-केस स्ट्रिंग्स का उपयोग करता है, तो आपको केवल लोअर-केस शब्दों का अनुक्रम मिलता है। puts ("babab".."zyzyz").grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/60 बाइट्स के लिए

— मूल्य इंक

7

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 स्वरों का उपयोग करके उदाहरण

— Emigna
स्रोत

कार्टेसियन उत्पाद का अच्छा उपयोग। नहीं सोचा होगा कि।

— मैजिक ऑक्टोपस Urn

7

पायथन 2 , 120 102 94 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

7

शुद्ध बैश, 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

— डिजिटल आघात
स्रोत

7

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।

— टाइटस
स्रोत

योग्य, एक छोटी गाड़ी भाषा कल्पना के साथ गोल्फ, मुझे यह पसंद है

— पैट्रिक रॉबर्ट्स

1

@PatrickRoberts यह एक बग नहीं है। यह एक सुविधा है। : मुझे दुख है कि उन्होंने $a="001";$a++;किसी दिन एक पूर्णांक को पूर्णांक में एम्बेड कर दिया । यह एक बहुत ही अटूट परिवर्तन था।

— टाइटस

1

for($s=$v=aeiouy;++$s<zyzza;)preg_match("#[^$v][$v][^$v][$v][^$v]#",$s)&&print"$s\n";आपको 1 बचाता है। अफसोस की बात है कि आपको उपयोग करने के लिए प्रिंट करने के लिए प्रतिध्वनि बदलनी होगी &&। \nवास्तविक लाइन ब्रेक के साथ प्रतिस्थापित करने से एक और बचत होती है।

— क्रिस्टोफ

1

आप कुछ वर्णों का उपयोग करके बचा सकते हैं, "#([^$v][$v]){2}[^$v]#"लेकिन मैंने इसका परीक्षण नहीं किया है।

— क्रिस्टोफ

1

@Christoph: Idk क्यों, लेकिन ([^$v][$v]){2}[^$v]लूप में काम नहीं करता है, जबकि [^$v]([$v][^$v]){2}करता है। दोनों काम स्टैंडअलोन (भले ही चर के साथ)।

— तैतस

6

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

— लुइस मेंडो
स्रोत

मुझे लगता है कि यह काम करना चाहिए, एक बाइट शेविंग: 11Y2'y'h2Y2yX~yyy&Z*( इसे ऑनलाइन आज़माएं! )

— कॉनर ओ'ब्रायन

@ ConorO'Brien दुर्भाग्य से, यह vcvcvपैटर्न बनाता है , cvcvcआवश्यकतानुसार नहीं । हालांकि धन्यवाद!

— लुइस मेंडो

6

पायथन, 92 बाइट्स

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

itertoolsजीत नहीं सकते । पायथन 2 में 1 बाइट लंबा है।

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

— XNOR
स्रोत

यह भयानक है ^ _ ^

— एबडेक्सटर

6

हास्केल, 54 51 बाइट्स

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

mapM func listसूचकांक के लिए संभावित पात्रों को ले कर सभी शब्दों का निर्माण करता है func (list!!i)।

संपादित करें: @xnor को बचाने के लिए 2 बाइट्स मिले और उसका हल ढूंढते हुए, मुझे एक और मिला।

— nimi
स्रोत

mapM id$take 5$cycle["bcdfghjklmnpqrstvwxz","aeiouy"]एक बाइट बचाता है।

— xnor

बेहतर अभी तक, mapM(cycle["bcdfghjklmnpqrstvwxz","aeiouy"]!!)[0..4]या mapM(["bcdfghjklmnpqrstvwxz","aeiouy"]!!)[0,1,0,1,0]। यह अच्छा होगा कि स्वर और व्यंजन को हार्डकोड न करें, लेकिन mapM(\n->[x|x<-['a'..'z'],elem x"aeiou"==odd n])[0..4]यह काफी नहीं बनाता है।

— xnor

@ एक्सनॉर: धन्यवाद! cycleस्पष्ट पुनरावृत्ति के साथ अपने पहले संस्करण की जगह एक अतिरिक्त बाइट बचाता है।

— निमि

5

ब्रेकीलॉग , 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

— Fatalize
स्रोत

मैं के लिए की जरूरत पर हैरान था gऔर bहै, लेकिन यह परीक्षण करते हैं, क्योंकि यह है jइनपुट के रूप में स्ट्रिंग की एक सूची लेने से मना करने लगता है? :eaवास्तव में प्रोलॉग / ब्रेकीलॉग की ताकत दिखाती है, और यह एक ऐसा कदम है जो अधिकांश अन्य भाषाओं को बहुत अधिक कठिन लगता है।

@ ais523 हाँ, मुझे भी आश्चर्य हुआ कि gऔर bजरूरत थी। jलगता है कि यह खराब हो गया है और यह केवल एक सूची से तर्कों की एक सूची को भेद करने की कठिनाई के कारण है। मैं इसे ठीक कर सकता हूं, हालांकि यह एक बार फिर कार्यान्वयन को जटिल बना देगा। मैं इसके साथ ही इसे ठीक नहीं कर सकता और ब्रैकलॉग के एक नए संस्करण में मुख्य समस्या को ठीक करने पर अपना समय निवेश कर सकता हूं।

— घातक

5

जावास्क्रिप्ट (ईएस 6), 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())।

— पैट्रिक रॉबर्ट्स
स्रोत

मैंने दो अलग-अलग तरीकों से समाधान को एक जनरेटर में बदलने की कोशिश की । केवल फ़ायरफ़ॉक्स द्वारा समर्थित शॉर्टहैंड फ़ॉर्म का उपयोग करना एक ही लंबाई है: f=(s='',i=2)=>(for(c of(i%2?'aeiouy':'bcdfghjklmnpqrstvwxz'))for(q of i?f(s+c,i-1):[s+c])q)मानक रूप का उपयोग करना दुर्भाग्य से एक लंबे समय तक है: function*f(s='',i=2){for(c of(i%2?'aeiouy':'bcdfghjklmnpqrstvwxz'))yield*i?f(s+c,i-1):[s+c]}अभी भी उस दिन की प्रतीक्षा कर रहा है जब एक जनरेटर सबसे छोटा विकल्प हो ...

— ETHproductions

1

btw, आप for...ofएक बाइट को बचाने के लिए स्टेटमेंट में इनर

— पार्न्स

5

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

असल में, मैं काउंटर हैं, और एस सभी वर्ण जिस पर हम एक काउंटर के लिए पुनरावृति करना चाहिए, वाली स्ट्रिंग की सरणी। लूप करते समय चाल आंतरिक है: इसका उपयोग काउंटरों को बढ़ाने के लिए किया जाता है, जो सबसे दाहिनी ओर से शुरू होता है। यदि हम देखते हैं कि अगला चरित्र जो हमें प्रदर्शित करना चाहिए, वह अंतिम शून्य है, हम काउंटर को शून्य पर पुनः आरंभ करते हैं और "कैरी" को अगले काउंटर पर प्रचारित किया जाएगा।

धन्यवाद क्रिस्टोफ़!

— धुंधला
स्रोत

PPCG में आपका स्वागत है!

— मार्टिन एंडर

1

char *cमुझे लगता है कि अंतरिक्ष अनावश्यक है।

— क्रिस्टोफ़

1

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]]);for(;--j>=0&&!s[j][++i[j]];)i[j]=0;puts("");}}

177 पर आ जाता है। आप और भी बेहतर कर सकते हैं;)

— क्रिस्टोफ़

2

7 बाइट्स सहेजने के i[5]={0}बजाय का उपयोग करना i[]={0,0,0,0,0}।

— फालकेन

1

@ क्रिसटोफ अहा, धन्यवाद। बहुत बढ़िया। लेकिन आपको यह अच्छा लग रहा था, इसीलिए मैं चुनौती को आगे बढ़ा रहा था (नहीं, मैं मजाक कर रहा हूं: मैंने ऐसा सिर्फ इसलिए किया क्योंकि मुझे गधे का दर्द है)। गंभीरता से, ज्ञानियों के लिए धन्यवाद।

— मंद

4

पर्ल, 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}के रूप में तत्वों के सभी क्रमपरिवर्तन लौटाता है।

— बापू
स्रोत

4

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 के रूप में आउटपुट करता है, अंतिम दो पंक्तियों पर तालिकाओं से प्राप्त संख्या के "अंक" के साथ।

— जेम्स होल्डरनेस
स्रोत

4

पर्ल 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, जो अफसोस की बात है।

— SMLS
स्रोत

4

पायथन 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]

— ElPedro
स्रोत

1

क्या मेरा पहला

— अनुकरण था

अपने सभी इंडेंटेशन के लिए रिक्त स्थान का उपयोग करने के बजाय आप एकल इंडेंट और टैब के लिए रिक्त स्थान का उपयोग कर सकते हैं।

— गेहूं जादूगर

4

पर्ल 6, 53 बाइट्स

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

किसी भी आउटपुट के लिए थोड़ा समय लगता है। बहुत अकुशल। नौकरी करता है।

— पागलों की तरह फुर्तीला ज्वेल्स
स्रोत

PPCG में आपका स्वागत है!

— मार्टिन एंडर

4

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जोड़ा गया।

— माइकल होमर
स्रोत

रेगेक्स का स्वाद किस पर आधारित है? (या यदि आपने अपना रोल किया है, तो यह किन विशेषताओं का समर्थन करता है? क्या इस पर कोई दस्तावेज़ीकरण है?)

— मार्टिन एंडर

@MartinEnder यह DFA ट्रैवर्सल से एक रोल-अपना है (एक DFA / NFA विज़ुअलाइज़र जो कि मैं छात्रों के लिए बनाया गया हूँ , जिसमें कुछ सीमित दस्तावेज हैं) से विकसित हुआ है - कोई बैकरेफरेंस नहीं, कुछ भी नॉन-रेगुलर नहीं। यह लंबे तार के लिए बहुत धीमा है। अभिव्यक्तियों की एकमात्र दिलचस्प विशेषता स्वयं के साथ संयोजन है &।

— माइकल होमर

मैंने पृष्ठ के बाकी हिस्सों के प्रलेखन को जोड़ा, और कुछ नमूने।

— माइकल होमर

1

लगता है कि आपने वर्ण वर्गों में श्रेणियां लागू कर दी हैं। तब आप कर सकते थे [bcdfghj-np-tvwxz]।

— मार्टिन एंडर

4

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 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 बाइट धन्यवाद) बाइट्स:

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

— नील
स्रोत

अच्छा लगा। तेज संस्करण में एक बाहरी स्थान है जिसे 101 बाइट्स के लिए हटाया जा सकता है

— ETHproductions

3

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

— बिजनेस कैट
स्रोत

'{,97>वर्णमाला पाने के लिए। और फिर "aeiouy"_'{,97>^एक और बाइट को बचाने के लिए 1$।

— मार्टिन एंडर

आपको पहले चरित्र की आवश्यकता नहीं है। यह माना जाता है कि यदि यह स्टैक की शुरुआत करने के लिए मिलता है।

— कीन

@ka दिलचस्प है, कि पता नहीं था। धन्यवाद।

— बिजनेस कैट

$ "aeiouy" _ '{, 97> ^] 3 * (;: m * N * $ $ संकेतों को अनदेखा करें। टिप्पणियों में कोड कैसे डालें।

— केयेन

@kaine बैकटिक्स का उपयोग करें, जैसे "` "।

— कॉनर ओ'ब्रायन

3

स्टैक्ड, नॉन-कमिंग, 51 बाइट्स

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

बहुत साधारण। यहाँ यह कोशिश करो!

— कोनोर ओ ब्रायन
स्रोत

3

पर्ल, 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

एक बदलाव के लिए पर्ल गोल्फ की कोशिश करना।
संपादित करें: ऐसा लगता है कि मुझे अभी भी बहुत कुछ सीखना है ... :)

— SMLS
स्रोत

एक अच्छा (भले ही प्राइमो का जवाब छोटा हो)। आप /$b[^$a]/&&say for"a"x5.."z"x5कुछ बाइट्स को बचाने के लिए अंत लिख सकते हैं । संपादित करें: और आप ड्रॉप और कर सकते $bहैं $a="aeiouy";/([^$a][$a]){2}[^$a]/&&say for"a"x5.."z"x5।

— दादा

इसके अलावा, आपको उद्धरण चिह्नों की आवश्यकता नहीं है aeiouy। इसके अलावा, चूंकि आपका regex 5 वर्णों के लिए जाँच करता है, आप कर सकते हैं a.."z"x5।

— दादा

@ दादा: धन्यवाद। किसी के रूप में जो सामान्य प्रोग्रामिंग के लिए पर्ल का उपयोग करता है, लेकिन अब तक गोल्फिंग के लिए नहीं, मैंने गैर-सख्त मोड का दोहन करने के लिए भी नहीं सोचा था। के कारण है कि मैं चुना है यही कारण है कि $aऔर $bचर नाम के रूप में, यहां तक कि कठोर मोड में घोषित किया जा सकता है क्योंकि उन की जरूरत नहीं है ... :) मैं भी पर्ल 6 एक बहुत का उपयोग इन दिनों, जो भी नहीं करता है एक गैर सख्त मोड।

— SMLS

3

स्काला, 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)

— jaxad0127
स्रोत

आप एक बाइट को बचाने के f"$c$d$e$f$g"साथ बदल सकते हैं ""+c+d+e+f+g।

— corvus_192

3

आर, 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))))

कोड गोल्फ में यह मेरा पहला कदम है, इसलिए मैं इसे नीचे काट देने के लिए किसी भी सुझाव का स्वागत करूंगा। अब तक यह सभी सुंदर मानक आर है; यहाँ केवल संभवतः मुश्किल बात यह है कि paste0 सबसे लंबे समय तक अपने तर्कों को याद करता है।

संपादित करें: rturnbull से प्रयुक्त असाइनमेंट ट्रिक, sapply(x,length)जिसके साथ प्रतिस्थापित किया गया है lengths।

— पैट्रिक बी।
स्रोत

साइट पर आपका स्वागत है! यह काफी अच्छा लग रहा है (मैंने केवल अपने आप में थोड़ा सा क्रमादेशित किया है) मैं सिर्फ आपके उत्तर में पुराने कोड को शामिल नहीं करने की सिफारिश करूंगा। संपादित इतिहास हमेशा उपलब्ध है, इसलिए कोई भी व्यक्ति इसे हमेशा देख सकता है। यह एक व्यक्तिगत शैलीगत बात है, इसलिए मेरी राय को अनदेखा करने के लिए स्वतंत्र महसूस करें।

— गेहूं जादूगर

आप 114 बाइट्स के लिए फ़ंक्शन असाइनमेंट के साथ इसे ब्रूट-फोर्स कर सकते हैं !

— Punintended

3

आर, 111 98 बाइट्स

yएक स्वर के रूप में जोड़ा गया , और @ बेटरिक बी के लिए धन्यवाद, 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सभी संभावित संयोजनों को उत्पन्न करने के लिए उपयोग करते हैं , जिसे हम पूर्व निर्धारित चर (वर्णमाला) से परिभाषित करते हैं । हम वर्णानुक्रम को सुनिश्चित करने के लिए संयोजनों को उल्टा करते हैं (जैसा कि पहले चर के लिए डिफ़ॉल्ट सबसे तेज़ होता है)। फिर हम मैट्रिक्स की प्रत्येक पंक्ति के माध्यम से पुनरावृति करते हैं, प्रत्येक पत्र को स्टैडआउट में प्रिंट करते हैं। हम यह सुनिश्चित करने के लिए तर्क का उपयोग करते हैं कि प्रत्येक शब्द एक नई लाइन पर शुरू होता है।VClettersfillcat

— rturnbull
स्रोत

अच्छा! बिल्ली में कुछ विकल्पों का उपयोग करके और "अक्षर": l = अक्षर; v = c (1,5,9) का नाम बदलकर आप इसे 98 वर्ण (स्वर के रूप में 'या' या 95 नहीं तो आगे) काट सकते हैं; 15,21,25); लागू (expand.grid (सी <-l [-v], वी <- एल [V], सी, वी, सी) [, 5: 1], 1, बिल्ली , भराव = टी, सेप = "")

— पैट्रिक बी।

@PatrickB। धन्यवाद! मैंने आपके सुझाव शामिल किए हैं।

— rturnbull

86 बाइट्स

— जे। डी।

2

क्लोजर, 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")))))

रोमांचक नहीं है ...

— NikoNyrh
स्रोत

2

रूबी, 65 61 बाइट्स

पूरी तरह से अलग दृष्टिकोण:

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

नई चीजें जो मैंने आज सीखीं: एरे # उत्पाद फ़ंक्शन

— जीबी
स्रोत

2

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

Ungolfed संस्करण:

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 मुद्रित।

— हाबिल टॉम
स्रोत

यदि आप एक ungolfed संस्करण डाल सकते हैं जो बेहद मदद करेगा।

— SIGSTACKFAULT

बाब से लेकर ज़ज़ीज़ तक हर शब्द

गणितज्ञ, 72 65 61 बाइट्स

व्याख्या

पर्ल, 47 बाइट्स

पायथन 3 - 110 बाइट्स

रूबी, 72 71 52 बाइट्स

05AB1E , 18 16 बाइट्स

पायथन 2 , 120 102 94 बाइट्स

शुद्ध बैश, 74

शुद्ध बैश, 84

PHP, 88 86 84 80 बाइट्स

MATL , 21 बाइट्स

पायथन, 92 बाइट्स

हास्केल, 54 51 बाइट्स

ब्रेकीलॉग , 18 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 91 90 बाइट्स

संपादित करता

व्याख्या

सी, 201 199 186 184 183 169 163 बाइट्स

पर्ल, 71 बाइट्स

Befunge, 95 बाइट्स

पर्ल 6 , 70 बाइट्स

पायथन 2 , 120 117 बाइट्स

पर्ल 6, 53 बाइट्स

xeger , 49 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 82 बाइट्स

CJam , 32 31 29 28 बाइट्स

स्टैक्ड, नॉन-कमिंग, 51 बाइट्स

पर्ल, 63 59 54 बाइट्स

स्काला, 87 86 बाइट्स

आर, 143 132 बाइट्स

आर, 111 98 बाइट्स

क्लोजर, 101 बाइट्स

रूबी, 65 61 बाइट्स

C 361 बाइट्स

व्याख्या