हर स्वर से युक्त शब्द खोजें

Question

आपके प्रोग्राम को इस शब्दसूची में वे सभी शब्द खोजने होंगे जिनमें सभी स्वर हैं ( a e i o u y)। ऐसा करने के आसान तरीके हैं, लेकिन मैं सबसे कम उत्तर की तलाश में हूं। मैं कोई भी भाषा लूंगा, लेकिन मैं बैश देखना चाहूंगा।

यहाँ एक उदाहरण है (बहुत सुधार किया जा सकता है):

cat wordlist.txt | grep "a" | grep "e" | grep "i" | grep "o" | grep "u" | grep "y"

आपका स्कोर कोड की लंबाई है।

शब्द के सभी घटनाओं की गिनती के लिए -5 अंक।

सबसे कम स्कोर जीतता है।

Comments

ऐसी प्रोफ़ाइल। बहुत सी तस्वीर। बहुत कुत्ता। वाह।

— दरवाज़े

17 जवाब और गिनती! मैं आपके जैसे cg, doc पर अधिक प्रश्न देखना चाहूंगा। अक्सर मुझे यहां कुछ दिलचस्प दिखाई देगा, लेकिन एक सभ्य समाधान का उत्पादन करने के लिए कई घंटों का समय नहीं है ...

— Cary Svelveland

हां, लेकिन यह स्वरों को खोजने के लिए समर्पित भाषा नहीं हो सकती है।

— TheDoctor

@ डॉक्टर शेक्स मुट्ठी

— जेसन सी

यदि इसके पास बोनस है, तो यह कोड-गोल्फ नहीं है। इसके बजाय कोड-चुनौती का उपयोग करें।

— टिम सेगिन

Answer 1

गोल्फस्क्रिप्ट, 20 चार्ट - 5 = 15 अंक

n%{'aeiouy'\-!},.,+`

हावर्ड के समाधान पर आधारित है , लेकिन एक छोटी परीक्षा ( \-!एक चार से अधिक बचाता है &,6=), छोटी लंबाई-एपेंडिंग ( .,+= 3 चार्ट) और छोटी आउटपुट स्वरूपण (कोई भी नहीं कहा कि उत्पादन newline- अलग किया गया था, इसलिए `एक चार से अधिक बचाता है n*) का उपयोग कर।

यहाँ आउटपुट है, इनपुट के रूप में लोअरकेस शब्द सूची (पठनीयता के लिए सम्मिलित लाइनब्रीक्स):

["abstemiously" "authoritatively" "behaviourally" "consequentially" "counterrevolutionary"
"disadvantageously" "educationally" "encouragingly" "eukaryotic" "evolutionarily"
"evolutionary" "exclusionary" "facetiously" "gregariously" "heterosexuality" "homosexuality"
"importunately" "inconsequentially" "instantaneously" "insurrectionary" "intravenously"
"manoeuvrability" "neurologically" "neurotically" "ostentatiously" "pertinaciously"
"precariously" "precautionary" "questionably" "revolutionary" "simultaneously"
"supersonically" "tenaciously" "uncomplimentary" "uncontroversially" "unconventionally"
"undemocratically" "unemotionally" "unequivocally" "uninformatively" "unintentionally"
"unquestionably" "unrecognisably" 43]

(Ps। तकनीकी रूप से, यह देखते हुए कि चुनौती केवल यह कहती है कि कोड को इस विशिष्ट इनपुट के लिए काम n%{'aeiouy'\-!},`43करना है, एक वर्ण अभी तक कम होगा। मैं उस धोखा को मानता हूं, हालांकि।)

---

स्पष्टीकरण:

• n% एक सरणी में newlines पर इनपुट को विभाजित करता है।
• { }, एक "grep" ऑपरेटर है, जो सरणी के प्रत्येक तत्व के लिए ब्रेसिज़ के बीच कोड को निष्पादित करता है और उन का चयन करता है जिनके लिए यह एक सही मूल्य देता है।
  • लूप के अंदर, 'aeiouy'\-शाब्दिक स्ट्रिंग लेता है aeiouyऔर इससे उम्मीदवार शब्द में पाए जाने वाले प्रत्येक वर्ण को हटा देता है। !तो तार्किक रूप से, जिसके परिणामस्वरूप स्ट्रिंग को नकारता, उपज 1(सही) यदि स्ट्रिंग खाली और है 0(गलत) यदि यह नहीं है।
• .,+ फ़िल्टर किए गए सरणी की एक प्रतिलिपि बनाता है, इसमें शब्दों की संख्या गिनता है, और परिणाम को मूल सरणी में जोड़ता है।
• आखिरकार, ` सरणी को अनइंस्टॉल करें, इसे अपनी सामग्री के एक स्ट्रिंग प्रतिनिधित्व में परिवर्तित करें। (इसके बिना, सरणी के शब्दों को केवल उत्पादन में संक्षिप्त किया जाएगा, एक अपठनीय गड़बड़ उपज।)

Comments

बधाई!! सबसे छोटा जवाब !!!!

— TheDoctor

संयमपूर्वक और स्पष्ट रूप से सभी 6 स्वरों के साथ एक ही शब्द है। बस सोचा था कि मैं आपके साथ साझा करूंगा। मुझे यह अच्छा लगा।

— dberm22

Answer 2

GolfScript, 19 अक्षर

n%{'aeiouy'&,6=},n*

उपयोग:

golfscript vowels.gs < wordlist.txt

आउटपुट:

abstemiously
authoritatively
behaviourally
[...]
uninformatively
unintentionally
unquestionably
unrecognisably

यदि आप भी अंत में गिनती का उत्पादन करना चाहते हैं तो आप इसका उपयोग कर सकते हैं

n%{'aeiouy'&,6=},.n*n@,

जो चार वर्ण लंबा है।

Comments

मुझें यह पसंद है! यह 4 वर्णों से अधिक लंबा हो सकता है, लेकिन इससे आपको -5 पीटी बोनस मिलता है

— TheDoctor

Answer 3

पायथन - 46 वर्ण

filter(lambda x:set(x)>=set("AEIOUY"),open(f))

पठनीय संस्करण: यह पहले से ही बहुत पठनीय है :-)

Answer 4

एपीएल, 21 - 5 = 16

(,≢)w/⍨∧⌿'aeiouy'∘.∊w

शब्दों की सूची खोजने की अपेक्षा करता है w। उन शब्दों की सूची लौटाता है जिनमें सभी स्वर होते हैं, साथ ही उनकी गिनती भी होती है। Ngn apl के साथ परीक्षण किया गया । यहाँ एक उदाहरण है ।

व्याख्या

         'aeiouy'∘.∊w   # generate a truth table for every vowel ∊ every word
       ∧⌿               # reduce with ∧ along the rows (vowels)
    w/⍨                 # select the words that contain all the vowels
(,≢)                    # hook: append to the list its own tally

Answer 5

रूबी 38

संपादित करें 34: अब तक (@OI से) सर्वश्रेष्ठ:

a.split.select{|w|'aeiouy'.count(w)>5} 

संपादन 1: मैंने सिर्फ 'y' के लिए पूछे गए प्रश्न को स्वरों के बीच शामिल करने पर ध्यान दिया है, इसलिए मैंने अपने प्रश्न को उसी के अनुसार संपादित किया है। जैसा कि @Nik ने अपने उत्तर के लिए एक टिप्पणी में बताया है, "aeiouy".charsएक चरित्र से कम है %w[a e i o u y], लेकिन मैं बाद में छोड़ दूंगा, विविधता के लिए, भले ही मैं अवसर की सीमा से अधिक बुरे सपने आ रहा हूं।

संपादित करें 2: सुधार सुझाने के लिए @OI को धन्यवाद:

s.split.select{|w|'aeiouy'.delete(w)==''}

जो मेरे पास पहले से 11 पात्रों को बचाता है।

3 और 3a संपादित करें: @OI ने कुछ और दस्तक दी है:

s.split.select{|w|'aeiouy'.tr(w,'')==''}

फिर

s.split.reject{|w|'aeiouy'.tr(w,'')[1]}

और फिर (3 बी):

a.split.select{|w|'aeiouy'.count(w)>5} 

मैं एक मात्र मुंशी हूँ!

यहां दो और अनिश्चित समाधान दिए गए हैं:

s.split.group_by{|w|'aeiouy'.delete(w)}['']       (43)
s.gsub(/(.+)\n/){|w|'aeiouy'.delete(w)==''?w:''} (48)

शुरू में मेरे पास था:

s.split.select{|w|(w.chars&%w[a e i o u y]).size==6}

sशब्दों से युक्त एक स्ट्रिंग है, जिसे न्यूलाइन्स द्वारा अलग किया गया है। sउस शब्द के एक सरणी में सभी पाँच स्वर शामिल हैं। रूबी से अपरिचित पाठकों के लिए, %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]और &सरणी चौराहा है।

मान लीजिए

s = "abbreviations\nabduction\n"
s.split #=> ["abbreviations", "abduction"] 

ब्लॉक में {...}, शुरू में

w             #=> "abbreviations"
w.chars       #=> ["a", "b", "b", "r", "e", "v", "i", "a", "t", "i", "o", "n", "s"]
w.chars & %w[a e i o u y] #=> ["a", "e", "i", "o"]
(w.chars & %w[a e i o u y]).size == 6 #=> (4 == 6) => false,

इसलिए "संक्षिप्त" का चयन नहीं किया गया है।

यदि स्ट्रिंग sमें डुप्लिकेट हो सकते हैं, तो डुप्लिकेट को हटाने के लिए s.split.select...प्रतिस्थापित किया जा सकता है s.split.uniq.select...।

बस मैं की जगह 1 वर्ण को बचा सकता है पर ध्यान size==6के साथ size>5।

Comments

...size=5एक बग है - होना चाहिए...size==5

— उरी अगासी

धन्यवाद, @ यूरी, पहली पंक्ति में टाइपो को इंगित करने के लिए, जो मैंने तय किया है (बग नहीं - '' संक्षिप्त रूप से ऊपर "लाइन चयनित नहीं है)।

— Cary Swoveland

@CarySwoveland आप ऐसा करके अपने आप को 11 अक्षर बचा सकते हैं:s.split.select{|w|'aeiouy'.delete(w)==''}

— OI

यह बढ़िया है, @OI। मैंने एक संपादन किया है और एक जगह मिली है जो ग्रे सेल्स में है।

— Cary Swoveland

@CarySwoveland यह 1 और चरित्र को बचाएगा s.split.select{|w|'aeiouy'.tr(w,'')==''}:। मुझे पूरा यकीन है कि अगर आप निल तर्क और 'सही' स्ट्रिंग पद्धति का उपयोग करते हैं, तो आप इसे 40 अक्षरों के नीचे प्राप्त कर सकते हैं। अभी भी देख रहे हैं ...

— OI

Answer 6

हास्केल - 67

main=interact$unlines.filter(and.flip map "aeiouy".flip elem).lines

Comments

यह कोड-गोल्फ है , आपको कोड को छोटा बनाने की कोशिश करनी चाहिए, उदाहरण के लिए,

— व्हाट्सएप

Answer 7

रूबी - 28 अक्षर (या 27 यदि yस्वरों से बाहर रखा गया है)

("ieaouy".chars-s.chars)==[]

चलाने की पूरी आज्ञा है (48 वर्ण):

ruby -nle 'p $_ if ("ieaouy".chars-$_.chars)==[]'

संपादित करें: प्रतिस्थापित किया गया puts के साथ pके रूप में @CarySwoveland ने सुझाव दिया

Comments

अच्छा लगा, @Nik। %w[a e i o u]होता है, 1 वर्ण को बचाने pके लिए puts, 3 अधिक।

— Cary Swoveland

थैंक्स, @CarySwoveland! मैं इसके बारे में भूल गया p, मैं शायद ही कभी इसका इस्तेमाल करता हूं। % W [] के लिए, यदि y स्वरों के सेट में शामिल है, तो चार्ट वाला संस्करण अभी भी छोटा है।

— निक O'Lai

@ NikO'Lai "aeiouy".delete(s)==''आपको कुछ अक्षर बचा सकता है।

— OI

बहुत अच्छा! उर खुद के समाधान के रूप में पोस्ट करें, @OI। मैं इसे

— आगे बढ़ाऊँगा

Answer 8

AWK - 29

/ एक / && / ई / && / i / && / ओ / && / यू / && / y /

चलाने के लिए: लोअरकेस शब्द सूची को सहेजें wordlist.txt । फिर करो:

mawk "/ a / && / e / && / i और& / o / && / u / && / y /" wordlist.txt

यदि आपके सिस्टम में नहीं है mawk, तो awkइसका उपयोग भी किया जा सकता है।

आप प्रोग्राम को सहेजने program.awkऔर करने mawkया करने के लिए इसे फ़ाइल से भी चला सकते हैं awk -f program.awk।

Comments

सही क्रम का चयन नौकरी में तेजी लाता है: '/y/&&/u/&&/i/&&/o/&&/a/&&/e/'!!

— एफ। हौरी

Answer 9

पायथन, 45 अक्षर

[w for w in open(f) if set('aeiouy')<=set(w)]

Answer 10

k [२२-५ = १ [वर्ण]

मैंने फ़ाइल "corncob_lowercase.txt" का नाम बदलकर "w" कर दिया है

शब्दों की गिनती [22 वर्ण]

+/min'"aeiouy"in/:0:`w

उत्पादन

43

सभी शब्द खोजें [25 वर्ण]

x@&min'"aeiouy"in/:x:0:`w

कुल मिलाकर 43 शब्द जिसमें सभी स्वर हैं (a e i o u y)

उत्पादन

"abstemiously"
"authoritatively"
"behaviourally"
..
..
"unintentionally"
"unquestionably"
"unrecognisably"

Answer 11

जावास्क्रिप्ट / JScript 147 (152-5), 158 (163-5) या 184 (189-5) बाइट्स:

यहाँ मेरा जावास्क्रिप्ट और JScript बुरी तरह "ungolfyfied" संस्करण है (164 152 152-5 = 147 बाइट्स):

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;}

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=6;for(z in c)i-=!!s[k].search(c[z]);i&&(r[r.length]=s[k]);}return r;}

आप @GaurangTandon को search()फंक्शन के लिए धन्यवाद , जिसने मुझे एक बाइट बचाई!

साथ आधारित regexp भयानक प्रदर्शन, लेकिन दोनों बड़े तथा छोटे (163-5 = 158 बाइट्स) का समर्थन:

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=RegExp(c[z],'i').test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

बेहतर प्रदर्शन के आधार पर , BUT बहुत अधिक बाइट्स लेता है (189-5 = 184 बाइट्स):

function(s,k,z,x,i,c,r,l){l=[];r=[];for(z in c='aeiouy'.split(''))l[z]=RegExp(c[z],'i');for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=l[z].test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

---

यह केवल अगर मज़े के लिए (175-5 बाइट्स) और एक जवाब के रूप में नहीं गिना जाएगा:

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;}

यह 1 उत्तर पर आधारित है, लेकिन इसमें एक 'ट्विस्ट' है: आप जान सकते हैं कि कोई शब्द कितनी बार मिला है।

आप बस इस तरह करते हैं:

var b=(function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;})('youaie youaie youaie youaie a word');

b.youaie //should be 4

चूंकि lengthइसमें सभी स्वर नहीं हैं, इसलिए इसे हटा दिया जाएगा और फिर भी बोनस के लिए एक उत्तर होगा।

---

आप इसे कैसे कहते हैं?

"सरल": आप फ़ंक्शन को अंदर लपेटते हैं ()और फिर ('string goes here');अंत में जोड़ते हैं ।

ऐशे ही: (function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;})('a sentence youyoy iyiuyoui yoiuae oiue oiuea');

यह उदाहरण केवल 1 स्ट्रिंग के साथ एक सरणी लौटाएगा: yoiuae

मुझे पता है कि यह सबसे खराब समाधान है, लेकिन काम करता है!

---

मैं क्यों गिन रहा हूँ -5?

खैर, जावास्क्रिप्ट / JScript सरणियों में सरणियों में एक संपत्ति ( length) होती है जो उन तत्वों की संख्या बताती है जो इसके पास हैं।

प्रश्न में पुष्टि होने के बाद, -5 का बोनस शब्दों की संख्या बताने के लिए है।

चूंकि शब्दों की संख्या उस संपत्ति में है, स्वचालित रूप से मेरे पास स्कोर -5 है।

Comments

1 char search()को indexOf()सहेजने के बजाय रुचि हो सकती है ।

— गौरांग टंडन

इसके अलावा, जहां तक मैं देख सकता हूँ, अपने कम से कम संस्करण में, आप की जरूरत नहीं है .split()पर "aeiouy"। जेएस उसी तरह एक सरणी और स्ट्रिंग पर लूप करता है। (इसे हटाने से आपको ~ 10 वर्णों की बचत होती है)

— गौरांग टंडन

Answer 12

रूबी ३ ९ ३ 39

वर्तमान में इनपुट और आउटपुट सहित पूरे कार्यक्रम की गिनती करते समय सबसे छोटी रूबी प्रविष्टि ।

के mapबजाय का उपयोग करके एक चार्ट सहेजा गया each:

$<.map{|w|w*5=~/a.*e.*i.*o.*u/m&&p(w)}

एक और संस्करण, प्रीटीयर आउटपुट के साथ 39 अक्षर:

puts$<.select{|w|w*5=~/a.*e.*i.*o.*u/m}

दोनों प्रोग्राम स्टड से इनपुट लेते हैं या कमांड लाइन तर्क के रूप में पारित फ़ाइल नाम के रूप में:
$ ruby wovels.rb wordlist.txt

यह yएक फावड़ा के रूप में उकसाने के लिए 3 अतिरिक्त पात्रों का खर्च करता है।

Comments

वैसे भी इसे Enumerable#grepछोटा करने के लिए उपयोग करने के लिए? उदाहरण के लिए, s.split.grep /a*e*i*o*u*y/मान sलेना नए शब्दों द्वारा अलग किए गए शब्दों की एक स्ट्रिंग है।

— OI

@OI एक दिलचस्प विचार है, लेकिन इसमें कुछ फ़िदलिंग की आवश्यकता होगी क्योंकि रेगेक्स के पास एक निश्चित क्रम में फावड़े हैं। इसलिए मैं स्ट्रिंग को मेल करने से पहले 5 बार .*दोहराता हूं, फावड़ियों के बीच।

— डानिएरो

क्या आप स्पष्ट कर सकते हैं? मान लीजिए s = "aeiouy\neiouay\nyuaioe\n"। फिर मेरे लिए s.split.grep /a*e*i*o*u*y/लौटता ["aeiouy", "eiouay", "yuaioe"]है। pryरूबी 2.0.0 में परीक्षण । महान समाधान, वैसे।

— OI

@ ओह ओह वाह, मैंने मान लिया कि ऑपरेटर का grepइस्तेमाल किया है =~, लेकिन जाहिर है यह उपयोग करता है ===। मेरा संदेह यह था कि यह सभी फावड़ियों से नहीं होने वाले तार से भी मेल खाएगा, क्योंकि उदाहरण के लिए /e*a*i*o*u*y/=~"eioy"काम करता है। मैं वास्तव में नहीं समझता कि ===एक रेक्स और ऑपरेटर के बीच वास्तव में क्या होता है। शानदार खोज; मेरा सुझाव है कि आप इसे स्वयं एक उत्तर के रूप में पोस्ट करें। संपादित करें मैं सही था: उदाहरण के लिए प्रयास करें "heya"।

— डानिएरो

मुझे लगता है कि आप सही हैं कि regex को ट्विकिंग की आवश्यकता है, हालांकि। मुझे ऐसे किनारे के मामले मिल रहे हैं जिनमें सभी स्वर नहीं हैं जो कि लीक कर रहे हैं। शायद सच होने के लिए बहुत अच्छा है।

— OI

Answer 13

गणितज्ञ (65 या 314)

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

b = Permutations[{"a", "e", "i", "o", "u","y"}]; Table[
 Select[StringSplit[
  URLFetch["http://www.mieliestronk.com/corncob_lowercase.txt"]], 
  StringMatchQ[#, (___ ~~ b[[i]][[1]] ~~ ___ ~~ 
      b[[i]][[2]] ~~ ___ ~~ b[[i]][[3]] ~~ ___ ~~ 
      b[[i]][[4]] ~~ ___ ~~ b[[i]][[5]]~~ ___ ~~ b[[i]][[6]] ~~ ___)] &], {i, 1, 
  Length[b]}]

~ 320 वर्ण। वैकल्पिक संकेतन का उपयोग करके कुछ को बचाया जा सकता है, और अतिरिक्त वर्णों को डिस्क्रिप्शन फाइल को स्ट्रिंग्स की सूची के रूप में तैयार करना खो दिया जाता है (मैथेमेटिका में शब्दकोश के लिए प्राकृतिक प्रारूप। अन्य भाषाओं में इस प्रस्तुतिकरण की आवश्यकता नहीं हो सकती है, लेकिन मैथेमेटिका करता है)। यदि हम उस कदम को छोड़ देते हैं, तो यह माना जाता है कि यह हमारे लिए संभाला गया है, वही दृष्टिकोण 250 वर्णों के तहत किया जा सकता है, और यदि हम गणित के अंतर्निहित शब्दकोश का उपयोग करते हैं, तो हमें बड़ी बचत भी मिलती है,

Map[DictionaryLookup[(___ ~~ #[[1]] ~~ ___ ~~ #[[2]] ~~ ___ ~~ #[[3]] 
~~ ___ ~~ #[[4]] ~~ ___ ~~ #[[5]]~~ ___ ~~ #[[6]] ~~ ___) .., IgnoreCase -> True] &, 
 Permutations[{"a", "e", "i", "o", "u","y"}]]

200 अक्षरों के नीचे। पाए गए शब्दों की संख्या की गणना करने के लिए केवल परिणाम को पास करने की आवश्यकता होती है Length[Flatten[]], जिसे ऊपर दिए गए कोड के किसी भी ब्लॉक के चारों ओर जोड़ा जा सकता है, या बाद में, उदाहरण के लिए, के साथ किया जा सकता है Length@Flatten@%। इस चुनौती के लिए निर्दिष्ट शब्द सूची में 43 मैच हैं, और गणितज्ञ शब्दकोश 64 देता है (और बहुत जल्दी है)। प्रत्येक डिक्शनरी में मिलान शब्द दूसरे में नहीं हैं। गणितज्ञ "अप्रमाणिक रूप से" पाता है, उदाहरण के लिए, जो साझा सूची में नहीं है, और साझा सूची में "यूकेरियोटिक" पाया जाता है, जो कि गणितज्ञ के शब्दकोश में नहीं है।

बेलिसरियस ने एक बहुत बेहतर समाधान प्रस्तावित किया। यह मानते हुए कि शब्द सूची पहले से ही तैयार की गई है और चर को सौंपा गया है l, वह गणितज्ञ के StringFreeQ[]कार्य के आधार पर एकल परीक्षण को परिभाषित करता है , फिर इस परीक्षण को Pick[]फ़ंक्शन का उपयोग करके शब्द सूची में लागू करता है। 65 वर्ण, और यह मेरे दृष्टिकोण से लगभग 400 गुना तेज है।

f@u_ := And @@ (! StringFreeQ[u, #] & /@ Characters@"aeiouy"); Pick[l,f /@ l]

Comments

65 वर्णों में: शब्द सूची f@u_:=And@@(!StringFreeQ[u,#]&/@Characters@"aeiouy");Pick[l,f/@l]कहाँ lहै

— डॉ। बेलिसरियस

ऐसा इसलिए है क्योंकि आप yएक स्वर के रूप में (ओपी आवश्यकताओं के अनुसार) पर विचार करना भूल गए थे

— डॉ। बेलिसरियस

@ सबिसिसरियस येप, मुझे लगता है कि मेरी टिप्पणी करने के बाद। मैं अपने परिणामों को उस निश्चित के साथ जाँच रहा हूँ।

— माइकल स्टर्न

@ सबिसरियस ने पुष्टि की - आपका समाधान खदान की तुलना में अधिक संक्षिप्त और तेज है। आप इसे अपने समाधान के रूप में क्यों नहीं पोस्ट करते हैं? मैं इसे वोट दूंगा।

— माइकल स्टर्न

धन्यवाद! यदि आपको यह पसंद है, तो अपने उत्तर को संपादित करें। मेरे लिए यह भाषा के साथ छोटे समाधान खोजने के बारे में है,

— रेम

Answer 14

पर्ल 6 - 35 अक्षर

@CarySwoveland के रूबी समाधान से प्रेरित:

say grep <a e i o u y>⊆*.comb,lines

यह grepप्रत्येक पंक्ति का चयन करता है , जिसके Trueलिए रिटर्न होता है <a e i o u y> ⊆ *.comb, जो पूछने का एक फैंसी तरीका है " इनपुट के अक्षरों से बना सेट का ('a','e','i','o','u','y')एक सबसेट ( ⊆) है *.comb?"

दरअसल, दोनों <a e i o u y>और *.combकेवल Lists बनाते हैं : ⊆(या (<=)यदि आप ASCII में फंस गए हैं) उन्हें Setआपके लिए बदल देता है ।

मुद्रित लाइनों की संख्या प्राप्त करने के लिए, यह 42 अक्षर - 5 = 37 बिंदु स्क्रिप्ट आउटपुट करेगा:

say +lines.grep(<a e i o u y>⊆*.comb)».say

Answer 15

सी - 96 बाइट्स

 char*gets(),*i,j[42];main(p){while(p=0,i=gets(j)){while(*i)p|=1<<*i++-96;~p&35684898||puts(j);}}

मैंने संचालक वरीयता के एक भाग्यशाली संयोग के लिए कोष्ठक के कई बाइट्स को धन्यवाद दिया।

Answer 16

जावास्क्रिप्ट - स्कोर = 124 - 5 = 119 !!!

संपादित करें: १14/०२/१४

function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z}

मुझे ~ 12 वर्णों को काटने में मदद करने के लिए @ इस्माईल मिगुएल का बड़ा धन्यवाद !

मैंने फैट एरो नोटेशन फंक्शन फॉर्म को हटा दिया है, हालाँकि मैंने देखा है कि इसका उपयोग शुरू हो गया है, यह काम नहीं करता है। पता नहीं क्यों ...

---

यह काम करने के लिए:

फ़ंक्शन के तर्क के रूप में न्यूलाइन द्वारा अलग किए गए सभी शब्दों को नीचे दिखाए अनुसार पास करें।

---

परीक्षा:

// string is "facetiously\nabstemiously\nhello\nauthoritatively\nbye"

var answer = (function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z})("facetiously\nabstemiously\nhello\nauthoritatively\nbye")

console.log(answer);
console.log(answer.length);

/* output ->    
    ["facetiously", "abstemiously", "authoritatively"]
    3 // count
*/

---

Comments

पंक्ति 1 पर सिंटैक्स त्रुटि: अपेक्षित अभिव्यक्ति, '>' c = (s, j) => {k = "aeiouy" .split ("

— इस्माइल मिगुएल

आप लूप के k="aeiouy".split("")अंदर होने से कम कर सकते हैं for(i in k)। ;नई लाइनों के बजाय विंडोज में कुछ बाइट्स का उपयोग करना । और फिर भी, मैं यह नहीं देखता कि यह शब्दों की सूची को कैसे संभालेगा। और इसे किस प्रकार कार्यशील बनाया जाए।

— इस्माईल मिगुएल

@IsmaelMiguel मुझे पता है कि यह (वसा तीर संकेतन) काम नहीं करता है। लेकिन जब से मैंने इसे यहां इस्तेमाल होते देखा था इसलिए मैंने इसका इस्तेमाल किया क्योंकि यह चरस को बचाता है। लेकिन मैंने उसे हटा दिया। और मैं आपकी टिप को नहीं समझता, धन्यवाद हालांकि जांच कोड के लिए। अपने बाइट्स टिप को शामिल करें। और मेरा नया कार्यक्रम आपकी दोनों शंकाओं को दूर कर सकता है। पढ़ने के लिए धन्यवाद। :)

— गौरांग टंडन

इसके बजाय k="aeiouy";o=0;for(i in k), प्रयास करें o=0;for(i in k='aeiouy')। और बाइट्स की बचत होती है का उपयोग कर, आप को बदलने के लिए उन्हें का उपयोग कर सकते o+=RegExp(k[i]).test(s)में o+=RegExp(k[i],'i').test(s), एक और बाइट लेने, लेकिन दोनों बड़े तथा छोटे साथ काम करना।

— इस्माईल मिगुएल

बेहतर एल्गोरिथ्म के साथ अपडेट किया गया। हालांकि मैं अब आपके विचार को समझ रहा हूं, लेकिन मुझे समझ नहीं आ रहा है कि यह यहां क्यों काम करता है और यहां नहीं । कृपया सहायता कीजिए! धन्यवाद :)

— गौरांग टंडन

Answer 17

बैश + कोरुटिल्स, 39

eval cat`printf "|grep %s" a e i o u y`

स्टड से इनपुट लेता है।

Comments

यह 5-पॉइंट बोनस के लिए योग्य है।

— ग्लेन रैंडर्स-पीरसन

@ GlennRanders-Pehrson उस बोनस से मुझे कोई मतलब नहीं है ;-)

— डिजिटल ट्रॉमा

यह समझ में आता है या नहीं, आप सही ढंग से 86 लाइनों का उत्सर्जन करते हैं जब फ़ाइल को शब्दसूची की दो प्रतियों के साथ संसाधित किया जाता है। समाधान जो केवल क्रमबद्ध करते हैं और केवल 43 रिपोर्ट करते हैं, उन्हें बोनस नहीं मिलेगा, जैसा कि मैं इसे समझता हूं।

— ग्लेन रेंडर्स-पीरसन

Answer 18

पाल 29 चरखा

/y/{/u/{/o/{/i/{/a/{/e/p}}}}}

गति की जांच के लिए विकिपीडिया पर पत्र आवृत्ति से चुना गया आदेश ।

मेरे मेजबान पर:

time sed -ne '/a/{/e/{/i/{/o/{/u/{/y/p}}}}}' </usr/share/dict/american-english >/dev/null 
real    0m0.046s

तथा

time sed -ne '/y/{/u/{/i/{/o/{/a/{/e/p}}}}}'</usr/share/dict/american-english >/dev/null 
real    0m0.030s

Comments

नाइस (+1), लेकिन मुझे लगता है कि 36 बाइट्स की गिनती के लिए आपको स्क्रिप्ट में "sed -n" शामिल करना होगा।

— ग्लेन रैंडर्स-पीरसन

Answer 19

बैश (grep) - 36 बाइट्स

g=grep;$g y|$g u|$g o|$g i|$g a|$g e

परीक्षण किए गए स्वरों के क्रम पर ध्यान दें, कम से कम पहले। परीक्षण मामले के लिए, यह aeiou y में परीक्षण के रूप में तेजी से लगभग 3 गुना चलता है। इस तरह पहला परीक्षण बड़ी संख्या में शब्दों को हटाता है इसलिए बाद के परीक्षणों में कम काम करना पड़ता है। जाहिर है कि इससे कोड की लंबाई पर कोई प्रभाव नहीं पड़ता है। यहाँ पोस्ट किए गए अन्य समाधानों में से कई इसी क्रम में परीक्षण करने से लाभान्वित होंगे।

Comments

क्यों wc, हम नहीं ढूँढ रहे हैं, गिनती नहीं? इसके अलावा, क्या हम इनपुट कोड को कैरेक्टर काउंट में गिनते हैं?

— ओरियन

मैं वास्तव में बोनस को नहीं समझता, "शब्द की सभी घटनाओं को गिनने के लिए -5 अंक"। अगर यह वास्तव में "शब्द की सभी घटनाओं की रिपोर्टिंग" का अर्थ है, तो यह है कि मेरी स्क्रिप्ट्स क्या करती हैं, बिना "wc" के। मैं किसी भी "इनपुट कोड" का उपयोग नहीं कर रहा हूं क्योंकि grep मानक इनपुट पढ़ता है, इसलिए "grep" "इनपुट कोड" है और मैंने इसे गिना। अब मैं "| wc" को हटा दूंगा।

— ग्लेन रेंडर्स-पीरसन

मैंने बोनस को अस्वीकार कर दिया है।

— ग्लेन रैंडर्स-पीरसन

Answer 20

डी - 196

import std.regex,std.stream;void main(string[]a){auto f=new File(a[1]);while(!f.eof)if(!(a[0]=f.readLine.idup).match("(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*").empty)std.stdio.writeln(a[0]);}

अन-गोल्फ :

import std.regex, std.stream;

void main( string[] a )
{
    auto f = new File( a[1] );

    while( !f.eof )
        if( !( a[0] = f.readLine.idup ).match( "(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*" ).empty )
            std.stdio.writeln( a[0] );
}

उपयोग :C:\>rdmd vowels.d wordlist.txt

wordlist.txt लोअरकेस सूची शब्दों में होना चाहिए।

Answer 21

Rebol (104 वर्ण)

remove-each w d: read/lines %wordlist.txt[6 != length? collect[foreach n"aeiouy"[if find w n[keep n]]]]

संयुक्त राष्ट्र के golfed:

remove-each w d: read/lines %wordlist.txt [
    6 != length? collect [foreach n "aeiouy" [if find w n [keep n]]]
]

dअब पाए गए शब्दों की सूची है। यहाँ Rebol कंसोल से एक उदाहरण दिया गया है:

>> ; paste in golf line.  This (REMOVE-EACH) returns the numbers of words removed from list

>> remove-each w d: read/lines %wordlist.txt[6 != length? collect[foreach n"aeiouy"[if find w n[keep n]]]]
== 58067

>> length? d
== 43

Answer 22

स्मालटाक (36/57 वर्ण)

'corncob_lowercase.txt' asFilename contents select:[:w | w includesAll:'aeiouy']

गिनती प्राप्त करने के लिए, परिणामी संग्रह में #size भेजें। परिणाम संग्रह में 43 शब्द ('अमूर्त' 'आधिकारिक रूप से' ... 'निर्विवाद रूप से' 'अपरिचित') शामिल हैं

ऊपर दिए गए कोड में 77 वर्ण हैं, लेकिन मैं शब्द सूची फ़ाइल का नाम बदलकर 'w' कर सकता था, इसलिए मैं फ़ाइल नाम को 1 के रूप में गिनता हूं, जो 57 का स्कोर देता है।

समस्या का फ़ाइल भाग पढ़ना है या नहीं? यदि नहीं (अन्य उदाहरण देखें), और शब्दों की सूची पहले से ही एक संग्रह सी में है, तो कोड कम हो जाता है:

c select:[:w | w includesAll:'aeiouy']

जो 36 वर्णों (अशुभ व्हाट्सएप हटाए गए) के साथ है।

Answer 23

अद्यतन: अनावश्यक रिक्त स्थान हटाए गए

बहुत धीमे लेकिन बैश में (81 वर्ण):

while read l;do [ `fold -w1<<<$l|sort -u|tr -dc ieaouy|wc -m` = 6 ]&&echo $l;done

संपादित करें: echo $l|fold -w1के साथ बदल fold -w1<<<$lके रूप में @ nyuszika7h ने सुझाव दिया

Comments

यह कोड गोल्फ है, आप अपने कोड को थोड़ा और कम करना चाहते हैं। अनावश्यक व्हाट्सएप को हटाकर शुरू करें। ;)

— nyuszika7h

आप fold -w1<<<$lइसके बजाय का उपयोग करके कोड को और छोटा कर सकते हैं echo $l|fold -w1। नोट: वर्तमान कोड 84 वर्णों का है, आपको अनुगामी न्यूलाइन की गणना नहीं करनी चाहिए।

— nyuszika7h

आज तक मुझे <<< के बारे में कुछ नहीं पता था। फिर से शुक्रिया, @ nyuszika7h क्या आप मुझे बता सकते हैं, जहां यह समझाया गया है।

— निक ओ'लाई

mywiki.wooledge.org/BashGuide/…

— nyuszika7h

Answer 24

जावास्क्रिप्ट - 95 बाइट्स

यहाँ मेरा गोल्फ है।

function f(s){return[var a=s.match(/^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/),a.length];}

और मैं यह भी बताना चाहूंगा कि आपके गोल्फ में स्वरों की सभी घटनाएं नहीं लगती हैं।

Ungolfed:

function countVowels(string) {
  var regex   = /^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/;
  var matches = string.match(regex);
  var length  = matches.length;
  return [matches, length];

Comments

युक्ति को और ध्यान से पढ़ें। वह ऐसे शब्दों की तलाश कर रहा है, जो --- जैसे स्पष्ट रूप से --- एक ही शब्द में सभी स्वरों को समाहित करता है। यद्यपि वह इस बात पर जोर नहीं देता है कि वे स्पष्ट रूप से क्रम में निहित हैं।

— dmckee

आपका रेगेक्स गलत है। सभी लुक-फॉरवर्ड प्रभावी रूप से जाँच रहे हैं कि क्या पहला वर्ण एक स्वर है। आपको (?=.*a)यह जांचने की आवश्यकता है कि क्या aस्ट्रिंग में कहीं है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

इसलिए मैं इस्तेमाल किया @dmckee lookaheads । उन्हें किसी विशिष्ट आदेश की आवश्यकता नहीं है।

— इसियाह मदीव्स

@nhahtdh कैच के लिए धन्यवाद

— Isiah Meadows

Answer 25

सॉर्ट + यूनीक + सेड

यह एक शब्द की बार-बार होने वाली घटनाओं से मेल नहीं खाता है। यह 'y' अक्षर से मेल नहीं खाता है अगर किसी शब्द की शुरुआत में होता है।

sort wordlist.txt | uniq | sed -n '/a/p' | sed -n '/e/p' | sed -n '/i/p' | sed -n '/o/p' | sed -n '/u/p' | sed -nr '/^[^y]+y/p' 

Comments

अपने अन्य उत्तर के रूप में, 4 बाइट्स को बचाने के लिए "सॉर्ट wordlist.txt | uniq" को "सॉर्ट -u wordlist.txt" से बदलें।

— ग्लेन रैंडर्स-पीरसन

Answer 26

दे घुमा के

ओपी जितना छोटा नहीं है, लेकिन बैश में एक लाइन:

while read p; do if [ $(sed 's/[^aeiouy]//g' <<< $p | fold -w1 | sort | uniq | wc -l) -eq 6 ] ; then echo $p; fi; done < wordlist.txt

Comments

आप "सॉर्ट-यू" के साथ "सॉर्ट | यूनीक" को बदलकर चार बाइट बचा सकते हैं।

— ग्लेन रैंडर्स-पीरसन

इसके अलावा आप कुछ और बाइट्स को बचाने के लिए रिक्त स्थान "|" और ";" से हटा सकते हैं

— ग्लेन रैंडर्स-पीरसन

Answer 27

सी # - 170

using System.Linq;class P{static void Main(string[]a){System.Console.Write(string.Join(",",System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)))));}}

प्रारूपित:

using System.Linq;
class P
{
    static void Main(string[] a) { 
        System.Console.Write(
            string.Join(",", System.IO.File.ReadAllLines(a[0])
                .Where(w => "aeiouy".All(c => w.Contains(c))))); 
    }
}

अभी मतगणना को लागू करने के मूड में नहीं हैं लेकिन आसान होना चाहिए। पहली दलील के रूप में शब्दसूची के (निचले-मामले वाले संस्करण) पथ को कार्यक्रम में पास किया जाना चाहिए:

program.exe D:\foo\bar\corncob_lowercase.txt

आउटपुट:

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably

मैंने शब्दों के आउटपुट और अल्पविराम को अलग करने की स्वतंत्रता ली; जिनमें से कोई भी नियमों में निर्दिष्ट नहीं है (कौन सा राज्य "सभी शब्दों को ढूंढना चाहिए", न कि कैसे (और अगर) आउटपुट के लिए)।

गिनती (+ आउटपुट) सहित: 192 - 5 = 187

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));System.Console.Write(string.Join(",",r)+" "+r.Count());}}

आउटपुट:

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably 4
3

(अंत में नोट पर ध्यान दें: 43)

कोई आउटपुट नहीं (" सभी शब्दों को खोजना होगा "): 137 - 5 = 132

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));}}

(नियमों को फिर से थोड़ा झुकाना: वास्तव में नहीं) यह सभी शब्दों को ढूंढता है और गणना निष्पादित करके उपलब्ध होती है r.Count()।

Answer 28

सी तेज

मैंने पहले कभी ऐसा नहीं किया है और मुझे बिल्कुल यकीन नहीं है कि पोस्टिंग प्रक्रियाएं क्या हैं। लेकिन यह क्या मैं के साथ आया है:

185 बाइट्स

Action<string>x=(s=>s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v)))Console.Write(w);}));using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

wordList = ए List<string> सभी शब्दों का।

यदि आप कुल प्रदर्शित करना चाहते हैं:

219 - 5 = 214 बाइट्स

Action<string>x=(s=>{var t=0;s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v))){Console.Write(w);t++;}});Console.Write(t);});using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

---

विस्तारित

// init
var words = "";
var vowels = "aeiouy";
var total = 0;

using (var stream = new StreamReader(@"C:\corncob_lowercase.txt"))
{
    // read file
    words = stream.ReadToEnd();

    // convert word to List<string>
    var wordList = words.Split('\n').ToList();

    // loop through each word in the list
    foreach (var word in wordList)

        // check if the current word contains all the vowels
        if(vowels.All (w => word.ToCharArray().Contains(w)))
        {
            // Count total
            total += 1;
            // Output word
            Console.Write(word);
        }

    // Display total
    Console.WriteLine(total);
}

Comments

आम तौर पर यदि प्रश्न "प्रोग्राम" के लिए पूछता है, तो आपको अपना पूरा कार्यक्रम लोडिंग / इनिशियलाइज़ेशन आदि सहित पोस्ट करना चाहिए, अन्यथा बहुत अच्छा काम करना चाहिए!

— प्रोग्रामरडान

ओह ठीक। तो छोटा संस्करण में मुझे आवश्यकता को प्राप्त करने वाली लाइन में सब कुछ शामिल नहीं होना चाहिए? मुझे लगा कि यह अन्य उत्तरों द्वारा निर्णय लेने वाला था क्योंकि उन्हें txt फ़ाइल को लोड / पढ़ने के लिए कोड की कमी थी।

— jzm

आपको दृष्टिकोणों में भिन्नता दिखाई देगी, और उत्तर देने की आयु को देखते हुए, क्यूरेटर के नए उत्तरों पर उतने मजबूत नहीं होने की संभावना है, लेकिन सामान्य तौर पर यदि प्रश्न "प्रोग्राम" के लिए कहता है, तो यह पोस्ट के रूप में संकलित और चलाने योग्य होना चाहिए। प्रश्न में ही उदाहरण लें - यह एक पूर्ण, निष्पादन योग्य समाधान है, जो अकेले खड़ा है।

— प्रोग्रामरडान

आह ठीक है। ठीक है, उस स्थिति में मैंने स्टैंडअलोन होने के लिए 2 छोटे संस्करणों को अपडेट किया है।

— jzm

महान! अपने उत्तर के पाठ को अपडेट करना सुनिश्चित करें (आप "लोडिंग / रीडिंग के बिना" का उल्लेख करते हैं) और अपने स्कोर की गणना करें।

— प्रोग्रामरडान

Answer 29

vb.net (स्कोर 91 = 96 सी - 5) _{* 0}

_{* ० + ४ ९ सी मिनट}

यह एक गणना बनाता है जिसमें सभी शब्द होते हैं जिनमें सभी स्वर होते हैं।

Dim r=IO.File.ReadLines(a(0)).Where(Function(w)"aeiou".Intersect(w).Count=5)
Dim c=r.Count

Comments

Your program must find all the words in this wordlist। यह एक) प्रोग्राम नहीं है, लेकिन प्रोग्राम का एक स्निपेट है और b) वर्डलिस्ट को पढ़ता / उपयोग नहीं करता है।

— रॉबथ

@RobIII vb.net में बेसिक कंसोल प्रोग्राम के लिए न्यूनतम 49 सी है। कार्यक्रम के तर्क (इस मामले में शब्दसूची) सरणी a हैं । साथ ही कुछ अन्य लोगों ने बताया कि यह LinqPad में मान्य कार्यक्रम है।

— एडम स्पाइट

Answer 30

गणितज्ञ - 136 102

Fold[Flatten@StringCases@## &, 
Flatten@Import@"http://bit.ly/1iZE9kY",
___ ~~ # ~~ ___ & /@ Characters@"aeiouy"]

छोटा लिंक http://www.mieliestronk.com/corncob_lowercase.txt पर जाता है

Comments

28 अक्षरों के साथ सहेजें http://bit.ly/1iZE9kY।

— 21

Characters["aeiou"]यदि आप शामिल हैं तो दो वर्णों को या अधिक के साथ सहेजें y।

— 21