19

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

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।

इनपुट एक स्ट्रिंग है जिसमें केवल मुद्रण योग्य ASCII चरित्र (0x20 से 0x7E, समावेशी) है।

आउटपुट एक स्ट्रिंग है जिसमें केवल 3 लगातार स्वरों के रन होते हैं। यदि इनपुट स्ट्रिंग में लगातार 3 से अधिक स्वर चल रहे हैं, तो आपके प्रोग्राम को उस रन में पहले तीन स्वरों सहित आउटपुट स्ट्रिंग का उत्पादन करना चाहिए, आगे लगातार स्वरों को छोड़ना चाहिए।

Y इस चुनौती के उद्देश्यों के लिए एक स्वर नहीं है।

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

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

"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."

code-golf string

— जोसेफ वीसमैन
स्रोत

2

आपको मिश्रित मामलों के साथ कुछ और परीक्षण शामिल करना चाहिए, जैसे aaYYAAaaaAERGH।

— ज़र्गब

5

पायथ, 21 बाइट्स

sfg3=Z&}rT0"aeiou"hZz

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

मैं सभी वर्णों के माध्यम से पुनरावृत्ति करता हूं और एक काउंटर का उपयोग करके मैंने कितने स्वरों को ट्रैक किया। हर बार जब मैं एक चार पास करता हूं, जो एक स्वर नहीं है, तो मैं काउंटर को 0. पर रीसेट करता हूं। जब भी काउंटर> 4 होता है, तो मैं पुनः चार्ज करता हूं।

sfg3=Z&}rT0"aeiou"hZz   implicit: z = input string
                                  Z = 0
 f                  z   test every char T in z; keep chars, that return true:
        rT0                convert T to lower
       }   "aeiou"         test if T is a vowel
      &           hZ       logical and with Z+1, 
                           gives 0 if ^ is false, otherwise Z+1
    =Z                     update Z with this value
  g3                       test if 3 >= Z
s                       sum up all remaining chars and print

— Jakube
स्रोत

10

अपठनीय , 1647 बाइट्स

' "" "" "'" " '" "" "" "'" "" ' "" "" "" ""' "" ' "" "'" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" " '" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" ' "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" " '" "" "" "" ""' "" "" "" ' "" "'" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "'" "" "" " '" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "'" "" "" " '" ""' "" " "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" "" ""' "" "" "" "" " '" "" "" "'" "" ' "" "" "" "" "" """ "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "'" "" "" " '" ""' "" "" "" "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" ""' "" "" "" "" " '" "" "" "'" " " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "' "" "" "" "" " '" "" "" "'" "" ' "" "" "" "" "" "" "" "" "" "" "" "" '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "'" "" "" " '" "" "" "'"" "" "" ' "" "" ""' "" "" "" ' "" "" "" "" "'" " '" "'" " '" "'" "" " "" ' ""' "" "" "" "" "" "" "" "" "" "" ' "" "'" ' "" "" "" "'" " '" "' "" "" "" "" " '" "'" "" ' ""' "" "" "" "" " '" ""' "" "" ' "'" "" """" ' ""' "" ' "" "" "" "" "'" " '" ""' "" "" "" "" "" "

व्याख्या

यह कार्यक्रम इस तरह छद्मकोश के बराबर है:

while (cp = (ch = read)) + 1 {
    (
        (cp -= 65) ?    // A
            (cp -= 4) ?     // E
                (cp -= 4) ?     // I
                    (cp -= 6) ?     // O
                        (cp -= 6) ?     // U
                            (cp -= 12) ?    // a
                                (cp -= 4) ?     // e
                                    (cp -= 4) ?     // i
                                        (cp -= 6) ?     // o
                                            (cp - 6) ?      // u
                                                0
                                            : 1
                                        : 1
                                    : 1
                                : 1
                            : 1
                        : 1
                    : 1
                : 1
            : 1
        : 1
    ) ? ((--vs)+4) ? print(ch) : (++vs) : {
        print(ch)
        vs = 0
    }
}

निम्नलिखित चर असाइनमेंट के साथ:

0   (unused)   (13 bytes)
1   cp         ( 4 bytes; occurs 20× in the code)
2   vs         ( 7 bytes; occurs  5× in the code)
3   ch         (10 bytes; occurs  3× in the code)

जैसा कि आप देख सकते हैं, मैंने वेरिएबल स्लॉट 0 से परहेज किया है क्योंकि 0लिखने के लिए इतना लंबा कंटेंट है।

इसलिए हम हर किरदार पढ़ सकते हैं और दोनों में मूल्य की दुकान cpऔर ch। हम संशोधित करेंगे, cpलेकिन chइधर-उधर रखेंगे ताकि जरूरत पड़ने पर हम उसे प्रिंट कर सकें। हम क्रमिक रूप से संख्या 65, 4, 4, 6, आदि को घटाते हैं, cpयह जांचने के लिए कि क्या यह ASCII में 10 संभावित स्वर वर्णों में से प्रत्येक है (ध्यान दें कि अंतिम को असाइन करने की आवश्यकता नहीं है)।

vsहमेशा 3 की संख्या से कम होता है, जो अभी भी मुद्रित होने की अनुमति देता है। यह बाहर शुरू होता है 0, इसलिए 3 स्वरों को मुद्रित किया जा सकता है। जब यह पहुंचता है -3, तो हम स्वरों को प्रिंट करना बंद कर देते हैं।

यदि हम एक गैर-स्वर (स्थान सहित) का सामना करते हैं, तो हम print(ch)उसके बाद निष्पादित करते हैं vs = 0। जैसा कि आपने शायद अनुमान लगाया है, यह स्वर काउंटर को रीसेट करता है।

यदि हम एक स्वर का सामना करते हैं , तो हम निष्पादित करते हैं ((--vs)+4) ? print(ch) : (++vs)। चलो इसे तोड़ दो:

कमी vs;
अगर मूल्य अब है -4, हम बहुत दूर चले गए हैं, इसलिए कुछ भी प्रिंट न करें, लेकिन वेतन वृद्धि vsवापस -3इसलिए हम स्वरों को प्रिंट करने से इनकार करते रहेंगे ;
अन्यथा, वर्ण मुद्रित करें।

— Timwi
स्रोत

1

यह भाषा अपने नाम के अनुरूप है।

— bkul

2

मुझे हमेशा इन भाषाओं में आश्चर्य होता है ... "क्या उन्होंने वास्तव में इसे हाथ से लिखा है? यदि हां, तो मुझे उन पर दया आती है ..." +1

— एडिसन क्रम्प

9

रेटिना , 25 बाइट्स

i`([aeiou]{3})[aeiou]+
$1

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

बहुत सीधा रेगेक्स प्रतिस्थापन। यह भी एक ही बाइट गिनती के लिए काम करता है:

Ri`(?<=[aeiou]{3})[aeiou]

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

3

आखिरकार! एक ऑनलाइन दुभाषिया! आपको इसे अपने गिथब पृष्ठ पर लिंक करने पर विचार करना चाहिए।

— mbomb007

6

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

एक अनाम फ़ंक्शन के रूप में

s=>s.replace(/[aeiou]+/gi,v=>v.slice(0,3))

— edc65
स्रोत

4

पर्ल, 27 वर्ण

(26 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प)

s/[aeiou]{3}\K[aeiou]+//gi

कोई बड़ी बात नहीं, बस एक दुर्लभ अवसर मुझे याद \Kहै।

नमूना रन:

bash-4.3$ perl -pe 's/[aeiou]{3}\K[aeiou]+//gi' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

— आदमी काम पर है
स्रोत

2

जब मैंने रेटिना उत्तर लिखा तो मुझे लगा "काश .NET regex होता \K"। :)

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

दिलचस्प है, @ मार्टिनबटनर। मुझे लगता है कि उन नियमित अभिव्यक्तियों को गंभीर स्टेरॉयड आहार पर रखा गया था। जिज्ञासा के लिए, क्या उनके पास पुनरावर्ती सबपैटर्न हैं? एक स्वर गणना को छोड़ने में मदद कर सकता है, हालांकि परिणाम लंबा है s/([aeiou]{1,3})(?1)+/$1/gi:।

— manatwork

दुर्भाग्य से, उनके पास पैटर्न का पुन: उपयोग नहीं है। उन दो बातें हैं कि कभी-कभी बनाना मुझे स्विच पर्ल या PCRE करने के लिए। जब मैं रेटिना के रेगेक्स स्वाद में कुछ सरल चीजों को पैच करने के लिए मिलता हूं, तो मुझे लगता है कि मैं उन्हें जोड़ूंगा (सच्ची पुनरावृत्ति नहीं, लेकिन कम से कम पैटर्न का पुन: उपयोग और परिमित पुनरावृत्ति)।

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

2

गंभीरता से, 34 बाइट्स

,;ù0╗`Ok"aeiou"Okd-Y;╜+*;╗4>`M@░εj

हेक्स डंप:

2c3b9730bb604f6b226165696f75224f6b
642d593bbd2b2a3bbb343e604d40b0ee6a

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

यह पाइथ उत्तर के रूप में एक ही एल्गोरिथ्म का उपयोग करता है, एक रजिस्टर में स्वरों की वर्तमान रन की लंबाई का ट्रैक रखते हुए स्ट्रिंग पर मैपिंग करता है, इसे बढ़ाता है जब भी वर्तमान वर्ण एक स्वर होता है, और यह जांचता है कि क्या यह अनुमत लंबाई से अधिक है, यदि ऐसा है तो 0 लौटाएं, और फिर इस उत्पन्न फ़िल्टर के साथ मूल स्ट्रिंग को फ़िल्टर करें। एक बार जब हम स्ट्रिंग्स पर सेट घटाव का उपयोग कर सकते हैं तो यह बहुत छोटा होगा। ( Okहटाया जा सकता है और Okdबस के साथ बदला जा सकता है @)। मैंने सुना है यह फीचर अगले अपडेट में आ रहा है ...।

— quintopia
स्रोत

2

सी, 166 बाइट्स

अब तक का सबसे छोटा जवाब नहीं, लेकिन मुझे लगता है कि ..

#define V v[1][i]!=
#define P printf("%c",v[1][i]),j
j;main(i,v)char**v;{for(i=0;V 0;i++)(V 97&V 'e'&V 'i'&V 'o'&V 'u'&V 65&V 69&V 73&V 79&V 85)?P=0:j>3?j++:P++;}

परीक्षण का मामला:

$ a.exe "We're queueing up for the Hawaiian movie."

We're queung up for the Hawaiin movie.

$ wc -c vowels.c 

166 vowels.c

— cleblanc
स्रोत

2

मैथमेटिका, 68 बाइट्स

a=Characters@"aeiouAEIOU";StringReplace[#,b:a~Repeated~{3}~~a..:>b]&

रेगेक्स उत्तर समान लंबाई होगा, लेकिन रेगेक्स का उपयोग कौन करता है?

— LegionMammal978
स्रोत

2

जावा, 115 बाइट्स

class a{public static void main(String[] a){System.out.println(a[0].replaceAll("(?i)([aeiou]{3})[aeiou]*","$1"));}}

प्रोग्राम पैरामीटर के रूप में इनपुट की अपेक्षा करता है।

इकाई परीक्षण उत्पादन:

Aei
screeen
We're queung up for the Hawaiin movie.

— टॉमस लैंगर
स्रोत

String[]और के बीच की जगह को हटाकर एक बाइट बचाएं a। String[]a

— प्रहार

के printबजाय का उपयोग करके 2 बाइट बचाओ println। मुझे विश्वास नहीं है कि कल्पना को एक नई रूपरेखा की आवश्यकता है।

— प्रहार

2

एपीएल, 40 चार्ट

{⍵/⍨1↓4≠⊃+/(1-⍳4)⌽¨⊂'aeiouAEIOU'∊⍨' ',⍵}

अंग्रेजी में:

'aeiouAEIOU'∊⍨' ',⍵: स्वरों को ढूंढें (और रोटेशन पर टूटने के लिए एक स्थान तैयार करें);
(1-⍳4)⌽¨⊂: 0, 1, 2, 3 बार (रैप-अराउंड) को दाईं ओर बुलियन वेक्टर पर धकेलना;
⊃+/ sum: रोटेशन और अनबॉक्स
1↓4≠: 4 से भिन्न को खोजें, और पहले वाले स्थान को हटा दें (जिस स्थान पर हम पहले से चल रहे थे)
⍵/⍨: तर्क में, केवल उस तत्व को रखें जहां योग 4 से भिन्न था।

— lstefano
स्रोत

1

पर्ल 6 , 36 35 बाइट्स

~~{S:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/} # 36 bytes~~

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' # 34 + 1 = 35 bytes

उपयोग:

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

सी (205 बाइट्स)

#include <stdio.h>
#define T(x)for(i=0;i<10;++i){if(v[i]==x){b=x;m=1;break;}}putchar(c);
main(b,c,i,m){char v[]="aeiouAEIOU";
while((c=getchar())!=EOF){if(!m){T(c);}else{if(b==c)continue;else{m=0;T(c);}}}}

(स्पष्टता के लिए एक लाइन ब्रेक जोड़ा गया)

— musarithmia
स्रोत

1

स्काला, 107 बाइट्स

readLine.foldLeft("",0)((a,n)=>if(!"aeiou".contains(n|32))a._1+n->0 else if(a._2>2)a else(a._1+n,a._2+1))_1

— रुस्लान
स्रोत

1

जावास्क्रिप्ट ईएस 6, 43 वर्ण

s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")

परीक्षा:

f=s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")
;`"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."`
.replace(/"/g,"").split("\n").every(s=>f((s=s.split(" => "))[0])==s[1])

— Qwertiy
स्रोत

1

x86 MS-DOS .COM फ़ाइल , 44 बाइट्स 36 बाइट्स

.COM फाइलें MS-DOS 1 से वर्तमान में व्यापक रूप से समर्थित हैं --- मैं dosemu में चल रहा हूं, केवल 8086 कमांड का उपयोग कर रहा हूं।

REPNE SCASB का उपयोग करके प्रत्येक स्वर का परीक्षण करने के लिए एक अलग कमांड का उपयोग करने के बजाय स्वर के परीक्षण के लिए 44 से 36 बाइट्स से कम किया गया।

Hex dump, reversible using `xxd -r -seek -256`:
0100: b3 03 43 b4 08 cd 21 88 c2 24 df b1 05 bf 1f 01   ..C...!..$......
0110: f2 ae 74 02 b3 05 4b 74 e9 b4 02 cd 21 eb e4 41   ..t...Kt....!..A
0120: 45 49 4f 55                                       EIOU

Unassembled using debug:
0100 B303    MOV BL,03     ; initialize counter to 3 (will increment by 1 to be 4)
0102 43      INC BX        ; increment counter--runs each time it hits 0 so it never goes <0
0103 B408    MOV AH,08     ; 
0105 CD21    INT 21        ; with AH=8, read 1 char without echo
0107 88C2    MOV DL,AL     ; copy input for potential output
0109 24DF    AND AL,DF     ; make input uppercase for testing
010B B105    MOV CL,05     ; count of 5 vowels to test against
010D BF1F01  MOV DI,011F   ; location of first vowel to test against
0110 F2AE    REPNE SCASB   ; test input against each vowel
0112 7402    JZ 0116       ; if input was not a vowel:
0114 B305    MOV BL,05     ;    reset counter to 5 (will decrement by 1 to be 4)
0116 4B      DEC BX        ; decrement counter regardless
0117 74E9    JZ 0102       ; if hit 0 (fourth or later vowel): goto 102
0119 B402    MOV AH,02     ; 
011B CD21    INT 21        ; with AH=2, print char
011D EBE4    JMP 0103      ; go to 103 for next character

bytes 011f-0123 contain the uppercase vowels AEIOU

— krubo
स्रोत

1

मतलाब / ऑक्टेव, 54 बाइट्स

@(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

उदाहरण:

>> @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')
ans = 
    @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

>> ans('We''re queueing up for the Hawaiian movie.')
ans =
We're queung up for the Hawaiin movie.

इसे आइडोन पर आज़माएं ।

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

1

वी , 21 बाइट्स (नॉनकमेटिंग)

ñ[aeiou]ñÍãqû3}úsq*

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

स्पष्टीकरण:

ñ[aeiou]ñ                     "Assign the string `[aeiou]` to register 'q'
         Íã                   "Search and replace on multiple lines (case insensitive):
           <C-r>q             "Register 'q'
                 û3}          "Repeated 3 times
                    ús        "Mark the following to be removed:
                      <C-r>q* "Register 'q' repeated any number of times

यह अधिक सरल समाधान की तुलना में मुश्किल से कम है:

Íã[aeiou]û3}ús[aeiou]*

(22 बाइट्स)

— DJMcMayhem
स्रोत

0

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

><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')

उदाहरण:

% ruby -e "$><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')" <<< "
Aeiou
screeeen
We're queueing up for the Hawaiian movie.
Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

— जोसेफ वीसमैन
स्रोत

आपने इसे लिखा है: "इनपुट एक स्ट्रिंग है जिसमें केवल मुद्रण योग्य ASCII चरित्र (0x20 से 0x7E, समावेशी) है।" फिर इसके साथ अतिरिक्त वर्ण खर्च $<.readकरने के लिए मल्टीलाइन इनपुट को संभालना (इस प्रकार श्रेणी वर्ण 0x0a से बाहर getsक्यों है?

— बजे मैनटवर्क

@manatwork यह एक बहुत अच्छी बात है, धन्यवाद! सोचें कि यह 2-3 बाइट्स बचा सकता है :)

— जोसेफ वीसमैन

इनपुट स्ट्रिंग से n लगातार स्वरों से अधिक निकालें

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

पायथ, 21 बाइट्स

स्पष्टीकरण:

अपठनीय , 1647 बाइट्स

व्याख्या

रेटिना , 25 बाइट्स

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

पर्ल, 27 वर्ण

गंभीरता से, 34 बाइट्स

सी, 166 बाइट्स

मैथमेटिका, 68 बाइट्स

जावा, 115 बाइट्स

एपीएल, 40 चार्ट

पर्ल 6 , 36 35 बाइट्स

सी (205 बाइट्स)

स्काला, 107 बाइट्स

जावास्क्रिप्ट ईएस 6, 43 वर्ण

x86 MS-DOS .COM फ़ाइल , 44 बाइट्स 36 बाइट्स

मतलाब / ऑक्टेव, 54 बाइट्स

वी , 21 बाइट्स (नॉनकमेटिंग)

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