मेरे पॉलीफ़्थॉन्ग का पता लगाएं!

Question

इस चुनौती के प्रयोजनों के लिए, एक पॉलीफ़थॉन्ग को एक स्ट्रिंग के एक सन्निहित स्लाइस के रूप में परिभाषित किया जाता है, जिसमें केवल स्वर होते हैं, और इसकी लंबाई कम से कम होती है। इनपुट के रूप में एक गैर-खाली स्ट्रिंग को देखते हुए, आपका कार्य सभी पॉलीफ़ेन्थों को आउटपुट करना है। ।

उदाहरण के लिए, "abeoic"निम्नलिखित सन्निहित स्लाइस (स्थान-अलग) हैं:

a b e o i c ab be eo oi ic abe beo eoi oic abeo beoi eoic abeoi beoic abeoic

उन चीज़ों को हटाने से जिनमें स्वर के अलावा कुछ भी होता है, या जिनकी लंबाई 2 से कम होती है, हमें हमारे वांछित पॉलीफिथॉंग मिलते हैं:

eo oi eoi

---

आपके नियमों को निम्नलिखित नियमों का पालन करना चाहिए:

• आप I / O के लिए लोअरकेस या अपरकेस चुन सकते हैं, लेकिन आउटपुट केस को इनपुट केस से मेल खाना चाहिए।

• स्वर aeiou(लोअरकेस के लिए) और AEIOU(अपरकेस के लिए) हैं। y/ Yस्वर नहीं माना जाता है।

• इनपुट में केवल मुद्रण योग्य ASCII होगा।

• यदि एक पॉलीफ़थॉन्ग कई बार दिखाई देता है, तो आप इसे केवल एक बार आउटपुट करने या इसकी सभी घटनाओं को आउटपुट करने के लिए चुन सकते हैं।

• किसी भी उचित I / O प्रारूप और विधि की अनुमति है (वर्णों की सूची भी ठीक है, इनपुट और आउटपुट दोनों के लिए)।

परीक्षण के मामलों

इनपुट -> आउटपुट (लोअरकेस)

r67 ^^ () * 6536782! 87 -> []
प्रोग्रामिंग पहेली और कोड गोल्फ -> []
आआंद… मैं जीत गया! -> ['आ', 'आ', 'आ' ']
abeoic -> ['eo', 'oi', 'eoi']
yah eioo ala -> ['ei', 'io', 'oo', 'eio', 'ioo', 'eioo']
@yabeeeayio__e -> ['ee', 'ee', 'ea', 'io', 'eee', 'eea', 'eeea']
0ioen0aaiosnjksd -> ['io', 'oe', 'aa', 'ai', 'io', 'ioe', 'aai', 'aio', 'aaio]

ध्यान दें कि परीक्षण मामलों 3 और 6 के लिए, आप केवल एक बार आउटपुट 'aa'और 'ee'क्रमशः (चौथा नियम देखें) कर सकते हैं।

यह कोड-गोल्फ है , हर भाषा में बाइट्स में सबसे कम सबमिशन जीतता है!

Comments

ध्यान दें कि यह मूल रूप से उन्नीसवीं बाइट में CMC (चैट मिनी चैलेंज) के रूप में पोस्ट किया गया था , लेकिन एडैम ने कहा कि यह मेन के लिए उपयुक्त है , इसलिए मैंने इसे पोस्ट करना समाप्त कर दिया।

— श्री Xcoder 13

मैं आपका तीसरा परीक्षण मामला, 'aa'दो बार प्रकट होता है। क्या एक ही स्ट्रिंग को कई बार आउटपुट करना पड़ता है यदि यह विभिन्न स्थानों पर दिखाई देता है या केवल एक ही उत्पादन अद्वितीय पॉलीफ़ोंग कर सकता है?

— जोनाथन फ्रीच

@JonathanFrech ठीक है, मुझे लगता है कि अद्वितीय polyphtongs का उत्पादन ठीक है। संपादित करेंगे।

— मिस्टर एक्सकोडर

क्या आउटपुट का क्रम मायने रखता है?

— ओव्स

@Xophmeister इस चुनौती के प्रयोजनों के लिए , एक पॉलीफिथॉंग को परिभाषित किया गया है - मुझे पता है कि यह सही भाषाई परिभाषा नहीं है :-)

— श्री एक्सकोडर

Answer 1

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

-5 बाइट्स के लिए @JonathanFrech को धन्यवाद

w=input();l=range(len(w)+1)
print{w[a:b]for a in l for b in l if b-a>1<set(w[a:b])<=set('aeiou')}

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

लोअरकेस I / O

Comments

मुझे लगता है कि आपको आवश्यकता नहीं है ...AEIOU', क्योंकि आपको इनपुट के रूप में केवल लोअरकेस अक्षर लेने की अनुमति है।

— जोनाथन फ्रीच

97 बाइट्स लंबे पायथन 3 संस्करण ।

— जोनाथन फ्रेच

@ जोनाथनफ्रेच print([w[a:b]for a in l for b in l[a+2:]if{*w[a:b]}<={*'aeiou'}])93 के लिए काम करता है।

— लिन

@ लियन और आपका समाधान 96 पायथन 2 बाइट्स का उत्पादन करता है ।

— जोनाथन फ्रेच

Answer 2

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

लोअरकेस में इनपुट की अपेक्षा करता है। पुनरावृत्ति के बिना अद्वितीय पॉलीफिथॉंग को आउटपुट करता है।

w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

परीक्षण के मामलों

let f =

w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

console.log(JSON.stringify(f("r67^^()*6536782!87")))
console.log(JSON.stringify(f("programming puzzles and code golf")))
console.log(JSON.stringify(f("aaand... i won!")))
console.log(JSON.stringify(f("abeoic")))
console.log(JSON.stringify(f("yah eioo ala")))
console.log(JSON.stringify(f("@yabeeeayio__e")))
console.log(JSON.stringify(f("0ioen0aaiosnjksd")))

कैसे?

हम पुनरावर्ती रूप से सभी संभावित पॉलीफिथॉन्ज के पेड़ का निर्माण करते हैं, जैसे ही वर्तमान नोड इनपुट में सम्‍मिलित नहीं होता है और कम से कम 2 वर्णों के सभी मिलान नोड्स को सहेजता है।

w => (                      // given the input w
  r = [],                   // r = array of results
  g = s =>                  // g = recursive function taking s
    w.match(s) &&           // if w contains s:
    [...'aeiou'].map(c =>   //   for each vowel c:
      g(s + c),             //     do a recursive call with s + c
      s[1] &&               //     if s is at least 2-character long:
      r.push(s)             //       push it into r
    )                       //   end of map()
)``                         // initial call to g() with s = ''
&& r                        // return r

Answer 3

रेटिना , 23 20 बाइट्स

M!&`[aeiou]+
r!&`..+

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

यह एक पॉलीफिथॉन्ग की सभी घटनाओं को प्रिंट करता है।

व्याख्या

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

तो वास्तविक कार्यक्रम:

M!&`[aeiou]+

स्वरों के सभी अतिव्यापी रन प्राप्त करें। वास्तव में इसका मतलब यह है कि सभी स्वरों के सभी प्रत्ययों को प्राप्त करना है।

r!&`..+

अब सभी उपसर्गों को प्राप्त करें जो कम से कम लंबाई 2 के हैं, दाएं से बाएं मिलान करके। यह Mयहाँ अंतर्निहित है, क्योंकि यह कार्यक्रम की अंतिम पंक्ति है।

Comments

क्या आप कोड समझा सकते हैं?

— एडम नो

!&`[aeiou]{2,}यह सही करने के लिए इतना करीब है , क्या यह लालच पाने का एक तरीका है ताकि इसके खिलाफ मेल खाता हो io?

— AdmBorkBork

@ Adám ने एक स्पष्टीकरण जोड़ा।

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

@AdmBorkBork मेरे विवरण में ऐसे कवर शामिल हैं जो काम नहीं कर सकते हैं। रेटिना वास्तविक रेगेक्स इंजन के साथ मेल नहीं खाता है, इसलिए सबसे अधिक &कर सकता है कि प्रत्येक स्थिति से एक मैच के लिए प्रयास करें, इसलिए आप एक ही स्थिति से अलग लंबाई के कई मैच नहीं कर सकते। इसलिए मुझे दूसरे चरण की आवश्यकता है।

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

अच्छी व्याख्या, धन्यवाद।

— AdmBorkBork

Answer 4

क्वाड्स , 20 + 1 = 21 बाइट्स

⊃,/⍵
[aeiou]+
1↓,\⍵M

oझंडे के साथ

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

हो रही चीजों के क्रम में:

[aeiou]+ इस PCRE के प्रत्येक मैच पर

,\⍵M मैच के उपसर्ग

1↓ पहले वाले को छोड़ दो (जिसमें एक स्वर है)

,/⍵ उपसर्गों की सभी सूचियों को संक्षिप्त करें

⊃ खुलासा (क्योंकि कटौती /संलग्न है)

---

यह Dyalog APL टैसिट फ़ंक्शन के बराबर है:

{⊃,/⍵}'[aeiou]+'⎕S{1↓,\⍵.Match}⍠'OM'1

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

Answer 5

गणितज्ञ, 92 बाइट्स

Select[Join@@Partition[r,i,1]~Table~{i,2,Length[r=(S=Characters)@#]},SubsetQ[S@"aeiou",#]&]&

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

Answer 6

जावा (ओपनजेडके 8) , 138 135 134 बाइट्स

s->{String e,x="";for(int i=0,j,y=s.length();i<=y;i++)for(j=y;j>i;x+=e.matches("[aeiou]{2,}")?e+" ":"")e=s.substring(i,j--);return x;}

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

Comments

i<y-1हो सकता है i<=yऔर String#matchesनिहित चेकों पूरे स्ट्रिंग है, तो आप की जरूरत नहीं है ^ और $। मुझे यह करने के लिए, हालांकि पिटाई के लिए +1। बस अपना १३ just बाइट उत्तर पोस्ट करने के बारे में था (लेकिन इन परिवर्तनों के साथ मैंने आपका प्रस्ताव छोटा है)। :)

— केविन क्रूज़सेन

Answer 7

जे , 34 29 बाइट्स

(*/@e.&'aeoui'*1<#)\\.#&,<\\.

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

Answer 8

जेली , 9 बाइट्स

ẆḟÐḟØcḊÐf

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

व्याख्या

ẆḟÐḟØcḊÐf  Main Link
Ẇ          Get all (contiguous) sublists
  Ðḟ       Filter; remove all elements where the result is truthy:
 ḟ  Øc     Filter; remove all vowels; if it's truthy, then it contains non-vowels
       Ðf  Filter; keep elements where the result is truthy:
      Ḋ    Dequeue; return all but the first element (truthy if the length was at least 2)

-4 बाइट्स मिस्टर एक्सकोडर की बदौलत

Comments

केL>1$$ साथ प्रतिस्थापित करके 11 बाइट्सL’$ ।

— श्री एक्सकोडर

वास्तव में आप की जगह ले सकता L’$के साथ Ḋके लिए 9 बाइट्स । एक समकक्ष होगा ẆṫLḊḟÐḟØc।

— मिस्टर एक्सकोडर

Answer 9

सी (जीसीसी) , 104 बाइट्स (केवल लोअरकेस या अपरकेस के साथ 99 बाइट्स)

हाँ, यह लीक है - तो क्या?

#include<string.h>
a;f(char*s){*s&&f(s+1);for(a=strspn(s=strdup(s),"AEIOUaeiou");a>1;)s[a--]=0,puts(s);}

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

Comments

के बिना काम करने लगता है#include , और आपको केवल एक पत्र मामले को संभालने की आवश्यकता है, इसलिए आप इसे 80 बाइट्स तक छोटा कर सकते हैं।

— स्टेडीबॉक्स

79 बाइट्स

— सीरत

Answer 10

आर , 137 बाइट्स

द्वारा outgolfed मार्क !

function(S)(x=unlist(sapply((s=el(strsplit(S,"[^aeiou]")))[nchar(s)>1],function(x)substring(x,1:(n=nchar(x)),rep(n:1,e=n)))))[nchar(x)>1]

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

function(S){
 s <- el(strsplit(S,"[^aeiou]"))            # split on non-vowels
 s <- s[nchar(s)>1]                         # vowel groups of length at least 2
 p <- function(x){                          # generates all substrings of inputs
  n <- nchar(x)
  start <- 1:n
  stop <- rep(n:1, n)                       # this will generate dups
  substring(x, start, stop)

 }
 q <- unlist(sapply(s, p))                  # all substrings
 q <- q[nchar(q)>1]                         # all length-2 or more substrings
}

Comments

आपको जरूरत नहीं है unique।

— मिस्टर एक्सकोडर

"किसी भी उचित I / O प्रारूप और विधि की अनुमति है (वर्णों की सूची भी ठीक है, इनपुट और आउटपुट दोनों के लिए)।" मैंने इसे आज़माया नहीं है, लेकिन मुझे संदेह है कि यदि आप शुरू से ही चरित्र सूचियों का उपयोग करते हैं तो यह काफी कम हो सकता है।

— 15:23 बजे user2390246

@ user2390246 शायद। मुझे विश्वास नहीं है कि यह आवश्यक रूप से मदद करेगा, लेकिन ऐसा शायद इसलिए है क्योंकि स्वरों के अलग-अलग रन के लिए दृष्टिकोण काफी अलग होगा और मैं अभी इसके चारों ओर अपना सिर नहीं लपेट सकता।

— Giuseppe

Answer 11

पर्ल 5, 53 +1 (-पी)

/[aeiou]{2,}(?{$h{$&}++})(?!)/g;$_=join$",sort keys%h

यह ऑनलाइन की कोशिश करो

Answer 12

पॉवरशेल , 93 88 बाइट्स

param($a)0..($b=$a.count-1)|%{($i=$_)..$b|%{-join$a[$i..$_]}}|?{$_-match'^[aeiou]{2,}$'}

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

लोअरकेस या अपरकेस I / O (या मिक्स!) का उपयोग करता है।

एक्सप्लोडेड सबस्ट्रिंग पर मेरे जवाब से उधार कोड सभी सबस्ट्रिंग प्राप्त करने के लिए, फिर उन लोगों को बाहर निकालता है जो रेगेक्स के -matchखिलाफ ^[aeiou]{2,}$- यानी, जो कम से कम दो स्वर लंबाई और केवल स्वर हैं। उन तारों को पाइपलाइन पर छोड़ दिया जाता है और आउटपुट निहित होता है।

Answer 13

हास्केल , 148 137 130 123 118 बाइट्स

@Laikoni -11 बाइट्स के लिए धन्यवाद, आगे -30 बाइट्स के लिए, मेरे लिए गोल्फ टिप्स, एक और -7 बाइट्स, और फिर भी एक और -5 बाइट्स की ओर इशारा करते हुए -7 बाइट्स।

यह हास्केल के लिए एक अच्छा फिट की तरह लग रहा था लेकिन परिणाम सहमत नहीं दिखता है। मुझे लगता है कि हास्केल सब के बाद एक ठीक-ठाक पसंद था। मैं अभी भी subsequencesकाम करता है जिस तरह से परेशान हूँ ।

import Data.List
v=(`elem`"aeiou")
p s=nub$do x<-groupBy((.v).(&&).v)s;[y|y@(c:_:_)<-subsequences x,v c,y`isInfixOf`x]

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

Comments

हास्केल गोल्फ में आपका स्वागत है! आप गोल्फ टिप्स के हमारे संग्रह , गोल्फ नियमों के मार्गदर्शक और मोनाड्स और मेन , हमारे हास्केल चैट रूम में रुचि ले सकते हैं।

— लैकोनी

आपके उत्तर पर कुछ नोट्स: न्यूलाइन्स की बाइट गिनती के समान है ;, लेकिन कोड की पठनीयता को बढ़ाते हैं। आप हमेशा eएक साथ उपयोग करते हैं v, इसलिए आप सीधे e=(एलएम की घोषणा कर सकते हैं "aeiou")। y!!0से छोटा है head y। के concatMapबजाय है concat.map, लेकिन यहां तक ​​कि छोटी भी है (=<<)सूची से monad wich समान प्रभाव है।

— लिकोनी

आप आयात कर सकते हैं Data.Listsके बजाय Data.List। पूर्व में उत्तरार्द्ध के सभी कार्य हैं, लेकिन अतिरिक्त सामान भी हैं powerslice, जो सभी निरंतर बाद की सूची देता है।

— नीमी

सूची की समझ में, आप y@(h:_:_)ड्रॉप length y>1और छोटा v(y!!0)करने के लिए मेल कर सकते हैं v h।

— लकोनी

मेरी आस्तीन में दो और इक्के होते हैं: (1) (\x y->v x&&v y)पॉइंट-फ़्री में कनवर्ट करके या तो मैन्युअल रूप से इस टिप का उपयोग करके या पॉइंटफ़्री .io का उपयोग करके छोटा किया जा सकता है । (२) सूची संन्यासी का उपयोग doसंकेतन के साथ भी किया जा सकता है, जो कि do x<-l;[...]समान है l>>=(\x->[...])। Btw, TIO पर आप अपने mainशीर्ष लेख या पाद लेख फ़ील्ड में बाइट की गिनती को वास्तविक सबमिशन से मिलान कर सकते हैं।

— लाकोनी

Answer 14

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

local $,=" ";print $_=~/(?=([AEIOU]{2,}))/ig;

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— 21

यदि आप डाउनवोट के बारे में सोच रहे हैं, तो यह स्वचालित रूप से सामुदायिक बॉट खाते द्वारा रखा गया था क्योंकि आपकी पोस्ट संपादित की गई थी। क्षमा करें, कुछ भी नहीं हम वास्तव में इसके बारे में कर सकते हैं, यह गूंगा व्यवहार है। उम्मीद है कि upvotes को स्वचालित डाउनवोट रिट्रैक्शन को ट्रिगर करना चाहिए।

— HyperNeutrino

Answer 15

आर , 120 बाइट्स 110 बाइट्स

function(x){k=nchar(x);i=k:1;e=expand.grid(i,i[-1]);grep("^[aeiou]+$",mapply(substr,x,e[,2],e[,2]+e[,1]),v=T)}

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

यह काम किस प्रकार करता है

function(x){                  #initalize the anonymous function where input is stored in x
  k=nchar(x)                  #set k to the number of characters in x
  i=k:1                       #create vector of integers from k to 1
  e=expand.grid(i,i[-1])      #create matrix of full outer join on i 
                              #except in the second column, limit i to being less than k
  grep("^[aeiou]+$",          #search for strings made of only vowels
       mapply(substr,         #map the substring function
              x,              #with x as the string to subset
              e[,2],          #start at the second column of the outer join
              e[,2]+e[,1]     #end at the sum of the sum of the first and second columns
       ),
       v=T                    #if a match is found, return it's value
  )
}                             #by default, R returns the last line of a function

Comments

105 बाइट्स अच्छा तरीका है, मैं अपने समाधान के लिए एक टिप्पणी जोड़ूंगा कि आपने मुझे आउट किया है :)

— Giuseppe

मैं ईमानदार रहूंगा, मुझे बहुत खुशी हुई कि मैं आपके लिए एक वैकल्पिक समाधान के साथ आने में सक्षम था :) आम तौर पर आप पहले से ही प्रकाश वर्ष हैं मेरे पास या मेज पर मेरे द्वारा छोड़े गए सभी कोड का पता लगाने के लिए।

— मार्क

Answer 16

सी, 119 बाइट्स

f(char*s){*s&&f(s+1);char*t,*b=calloc(strlen(s),1);for(t=b;*s==65|*s==69|*s==73|*s==79|*s==85;b[1]&&puts(b))*t++=*s++;}

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

Answer 17

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

s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')

संभवत: बहुत से गोल्फिंग करना बाकी है।

let f=
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')
console.log(JSON.stringify(f('r67^^()*6536782!87')))
console.log(JSON.stringify(f('programming puzzles and code golf')))
console.log(JSON.stringify(f('aaand... i won!')))
console.log(JSON.stringify(f('abeoic')))
console.log(JSON.stringify(f('yah eioo ala')))
console.log(JSON.stringify(f('@yabeeeayio__e')))
console.log(JSON.stringify(f('0ioen0aaiosnjksd')))

Answer 18

पर्ल 5 , 44 + 1 ( -n) = 45 बाइट्स

map{say}/(?=([aeiou]{$.}))/g while$.++<y///c

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

Answer 19

05AB1E , 10 बाइट्स

Œʒg≠}ʒžMм_

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

स्पष्टीकरण:

Œʒg≠}ʒžMм_  
Π           Push all substrings (abeoic => a, b, e, ..., eoi, eoc, ... abeioc)
 ʒ  }        Filter elements for which result is 1
  g≠            Push 1 if length is != 1, 0 otherwise
     ʒ       Filter elements for which result is 1
      žMм       Remove all occurences of 'aeiou' from element
         _      Negative bool: push 1 if length == 0, 0 otherwise

Comments

अच्छा उत्तर! मेरे पासŒʒžMм_}ʒg≠

— श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद। मेरे पास ŒD1ùKʒžMм_10 बाइट्स भी थीं । मैं इसे नीचे गोल्फ करने के लिए एक रास्ता खोजने की कोशिश कर रहा हूँ हालांकि

— scottinet

Answer 20

सी, 105 75 बाइट्स

एक संकेत जो इनपुट को कम करने के लिए एक पॉइंटर को स्वीकार करता है, और मानक आउटपुट पर अंतरिक्ष-अलग तारों का उत्पादन करता है:

i;f(char*p){for(i=strspn(p,"aeiou");i>1;)printf("%.*s ",i--,p);*p&&f(p+1);}

परीक्षण कार्यक्रम

#include <stdio.h>

int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        char *in = argv[i];
        printf("'%s' -> [ ", in);
        f(in);
        puts("]");
    }
}

डेमो

'r67^^()*6536782!87' -> [ ]
'programming puzzles and code golf' -> [ ]
'aaand... i won!' -> [ aaa aa aa ]
'abeoic' -> [ eoi eo oi ]
'yah eioo ala' -> [ eioo eio ei ioo io oo ]
'@yabeeeayio__e' -> [ eeea eee ee eea ee ea io ]
'0ioen0aaiosnjksd' -> [ ioe io oe aaio aai aa aio ai io ]

व्याख्या

#include <string.h>
#include <stdio.h>

void find_polyphthongs(char *p)
{
    /* from longest polyphthong substring down to 2 */
    for (int i = strspn(p,"aeiou");  i >= 2;  --i) {
        /* print exactly [p .. p+i] */
        printf("%.*s ", i, p);
    }

    /* tail-recurse to next char */
    if (*p) {
        find_polyphthongs(p+1);
    }
}

डेबियन लिनक्स पर जीसीसी का उपयोग करना, मैं की असंगत निहित घोषणाओं के साथ दूर होने लगते हैं strchr()और printf()। अन्य प्लेटफार्मों की आवश्यकता हो सकती है <stdio.h>और <string.h>शामिल किया जाना चाहिए।

इसे ऑनलाइन आज़माएं (जावास्क्रिप्ट की आवश्यकता है)।

Comments

कर सकते हैं f(p)char*p;नहीं हो f(char*p)?

— जोनाथन फ्रेच

बिल्कुल सही - मेरे पास मूल रूप से कॉलर-आवंटित भंडारण के लिए आउटपुट था f(s,d)char*s,*d:।

— टोबे स्पीट

102 बाइट्स ।

— जोनाथन फ्रीच

Answer 21

एपीएल (डायलॉग) , 53 बाइट्स

यह एक Dfn( d irect f unctio n ) है। उपयोग है p '<argument>'। निष्पक्ष चेतावनी: यह input > 8 charactersटीआईओ के लिए बहुत कुशल और समय से बाहर नहीं है , लेकिन पर्याप्त समय दिए जाने पर सामान्य रूप से काम करता है।

p←{(G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵}

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

16 बाइट्स के लिए @ Adám को धन्यवाद!

यह काम किस प्रकार करता है:

यह समझना आसान है कि क्या हम छोटे भागों में कोड को तोड़ते हैं:

• भाग 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: फ़ंक्शन का यह हिस्सा (दाएं) तर्क की लंबाई लेता है और वेक्टर aeiouको खुद में मिलाता है कि कई बार, [2, length(right arg)]स्वरों के हर संभव संयोजन को उपजता है।
• भाग 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: यह भाग जाँचता है कि कौन सा तत्व (s) इनपुट के सबस्ट्रिंग के सदस्य हैं। यह एक बुलियन वेक्टर देता है, 1जो कि इनपुट में मौजूद स्वर संयोजनों के सूचकांकों पर है और 0वे नहीं हैं। परिणामी वेक्टर को तब मैप किया जाता है ( /) Gसत्य मानों के अनुरूप तत्वों को लौटाता है।

पूरी बात तो सौंपी गई है p। p←बाइट गिनती में शामिल नहीं है क्योंकि यह आवश्यक नहीं है , यह सिर्फ फ़ंक्शन का उपयोग करना आसान बनाता है।

Comments

आगे गोल्फ। इसके अलावा, आपको ⊆फ़िल्टर करने के लिए उपयोग नहीं करना चाहिए । का उपयोग करें /।

— एडम

Answer 22

हास्केल , 74 बाइट्स

f[]=[]
f(h:t)=filter(all(`elem`"aeiou"))[h:take i t|i<-[1..length t]]++f t

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

Answer 23

रूबी 2.4, 100 बाइट्स

(2..(b=(a=gets).size-1)).to_a.flat_map{|i|(0..(b-i)).to_a.map{|j|a[j,i]}}.select{|k|k=~/^[aeiou]+$/}

यह गोल्फ में मेरा पहला प्रयास है, और मुझे यकीन है कि इस कोड को छोटा करने के बहुत सारे तरीके हैं।

Answer 24

रूबी , 80 बाइट्स

->s{[*0..z=s.size-2].product([*2..z]).map{|v|s[*v][/[aeiou]{2,}/]}.uniq.compact}

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

Comments

.compactहो सकता है-[nil]

— स्नैक

Answer 25

अजगर , 15 बाइट्स

f&tT!-T"aeoi".:

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

निश्चित रूप से गोल्फ के लिए, मैं स्पष्टीकरण लिखने से पहले इसे बेहतर करना चाहता हूं।

---

Answer 26

टी-एसक्यूएल (एसक्यूएल सर्वर 2014), 281 बाइट्स

;with s as(select substring(@,1,1)C,stuff(@,1,1,'')D,1 R union all select substring(D,1,1),stuff(D,1,1,''),R+1from s where len(D)>0),c as(select R i,C w from s where C LIKE'[aeiou]'union all select R,w+C from c join s ON i+1=R where s.C LIKE'[aeiou]')select w from c where len(w)>1

इनपुट द्वारा दें

declare @ varchar(max) = 'abeoic'

sआदेश दिए गए अलग-अलग अक्षरों में इनपुट को उड़ाने के लिए एक सामान्य तालिका अभिव्यक्ति का उपयोग करता है , और फिर cसभी स्वरों को बाहर करने के लिए गैर स्वरों को बाहर निकालने के लिए एक दूसरी आम तालिका अभिव्यक्ति का उपयोग करता है।

एसक्यूएल फिडल

Answer 27

PHP, 139 बाइट्स

function y($s){$p=[];$l=strlen($s);for($i=2;$i<=$l;$i++)for($j=0;$j<=$l-$i;$j++)strspn($a=substr($s,$j,$i),'aeiou')==$i&&$p[]=$a;return$p;}

ऑनलाइन डेमो

function yreadable($s)
{
    $p = [];
    $l = strlen($s);
    for($i=2; $i<=$l; $i++)
        for($j=0; $j<=$l-$i; $j++)
            strspn($a=substr($s,$j,$i),'aeiou')==$i
            && $p[] = $a;
    return $p;
}

यह काम किस प्रकार करता है

आसन्न वर्णों से मिलकर उप-स्ट्रिंग्स (2 की लंबाई के साथ शुरुआत) का चयन करें और स्ट्रिंग के साथ आगे बढ़ें। किसी भी उप-स्ट्रिंग्स को इकट्ठा करें जिसमें केवल स्वर होते हैं। अब उप-स्ट्रिंग्स के साथ दोहराएं।

स्ट्रिंग 'एब्सडेफ' के लिए ये सब जेनरेट किए गए और जाँच किए गए विकल्प हैं:

'ab','bc','cd','de','ef'
'abc','bcd','cde','def'
'abcd','bcde','cdef'
'abcde','bcdef',
'abcdef'