ला ला लैंड… नो वेट, मू मू मूनलाइट

122

यह चुनौती ऑस्कर 2017, ला ला लैंड मूनलाइट में सर्वश्रेष्ठ चित्र के विजेता को श्रद्धांजलि है !

एक फ़ंक्शन / प्रोग्राम लिखें जिसमें केवल अक्षरों से युक्त एक स्ट्रिंग होती है [A-Za-z], चार प्रतीक जो हर दिन के वाक्यों .,'?और स्थानों में सामान्य होते हैं , और ला ला लैंड की शैली में स्ट्रिंग को आउटपुट करते हैं।

अधिक विशिष्ट होने के लिए, पत्रों को पहले स्वर समूह में शामिल करें और शामिल करें, और प्रिंट / आउटपुट दो बार हर बार एक स्थान जोड़ते हैं, फिर पूरे स्ट्रिंग को प्रिंट / आउटपुट करते हैं। y इस चुनौती में एक स्वर है। विराम चिह्न और पूंजीकरण रखा जाना चाहिए।

आप मान सकते हैं कि सभी तारों में कम से कम एक स्वर होता है, और यह कि सभी तार एक अक्षर से शुरू होते हैं।

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

Land
La La Land

Moonlight
Moo Moo Moonlight

quEueIng
quEueI quEueI quEueIng

This isn't a single word.
Thi Thi This isn't a single word.

It's fun to play golf
I I It's fun to play golf

Ooo
Ooo Ooo Ooo

I'm okay
I I I'm okay

Hmm, no. There will be at least one vowel, but it can be anywhere.
Hmm, no Hmm, no Hmm, no. There will be at least one vowel, but it can be anywhere.

Why is y a vowel?
Why Why Why is y a vowel?

यह कोड-गोल्फ है इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है। स्पष्टीकरण को प्रोत्साहित किया जाता है , मुख्यधारा की भाषाओं में भी।

code-golf  string 
— स्टीवी ग्रिफिन
स्रोत
1
केस असंवेदनशीलता के लिए टेस्ट केस MOONLIGHT:। और सिर्फ मनोरंजन के लिए:Why did the chicken cross the road?
— टाइटस
35
द्वारा प्रायोजित चुनौती: राष्ट्रीय
— हकलाना
6
या प्रो। क्विरेल
— ब्रायन जे
1
6 वां टेस्ट केस लुइस प्राइमा और जंगल बुक द्वारा खरीदा गया। इस (खराब) वाक्य को जोड़ने के लिए बस शामिल हुआ।
— टॉबी

जवाबों:

30

05AB1E , 23 19 18 बाइट्स

ओकेक्स के लिए 1 बाइट धन्यवाद ।

Dlð«žOsSåJTk>£D¹ðý

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

 Dl                  # create a lowercase copy of implicit input
   ð«                # append a space
     žO              # push the vowels
       s             # swap lowercase input to the top of the stack
        S            # split into a list of chars
         å           # check each char for membership in the vowel-string
                     # (creates a list with 1 at the index of vowels and 0 for non-vowels)
          J          # join to string
           Tk        # find the index of 10
             >       # increment
              £      # take that many items from input
               D     # duplicate this string
                ¹    # push input
                 ðý  # join the strings by space
— Emigna
स्रोत
25

जेली , 24 22 20 19 14 बाइट्स

इमिग्ना के शानदार जवाब से एक चाल का उपयोग करके -5 बाइट्स (isVowel सूची में 10 के लिए देखो)

;⁶e€Øyw⁵ḣ@;⁶Ȯ;

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

15 बाइट विकल्प:

;⁶e€Øyw⁵ḣ@;⁶ẋ2;

यहां फुल टेस्ट सूट है।

कैसे?

;⁶e€Øyw⁵ḣ@;⁶Ȯ; - Main link: string s
 ⁶             - space character
;              - concatenate to s (for all vowel edge case)
    Øy         - vowels + y yield
  e€           - exists in? for €ach (gives a list of isVowel identifiers)
       ⁵       - 10
      w        - index of first sublist (with implicit decimalisation of 10 to [1,0])
        ḣ@     - head with reversed @rguments (start of word up to & including vowel group)
           ⁶   - space character
          ;    - concatenate (start of word up to & including vowel group plus a space)
            Ȯ  - print and yield (hence a full program...
               -     ...the alternative ẋ2 repeats instead in order to return the result)
             ; - join with the input, s
               - implicit print (of the second repetition and input string)
— जोनाथन एलन
स्रोत
18

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

5 + 1 बाइट संपादित करें thx @Arnauld को बचाया

एक ही चाल का उपयोग करते हुए अन्य की तुलना में लंबे समय तक (हमेशा की तरह)

x=>x.replace(/.*?[aeiouy]+/i,'$& $& $&')


let f=
x=>x.replace(/.*?[aeiouy]+/i,'$& $& $&')

test=`Land
La La Land

Moonlight
Moo Moo Moonlight

queueing
queuei queuei queueing

This isn't a single word.
Thi Thi This isn't a single word.

It's fun to play golf
I I It's fun to play golf

Ooo
Ooo Ooo Ooo

I'm okay
I I I'm okay

Hmm, no. There will be at least one vowel, but it can be anywhere.
Hmm, no Hmm, no Hmm, no. There will be at least one vowel, but it can be anywhere.`
test.split(`\n\n`).forEach(z=>{
  var [i,k]=z.split(`\n`),x=f(i);
  console.log(k==x ? 'OK':'KO',i+'\n'+x);
})
स्निपेट का विस्तार करें

— edc65
स्रोत
@Arnauld नहीं, लेकिन मैं उपयोग कर सकता था '$& $& $&'- मैं हमेशा विशेष डॉलर के चार्ट भूल जाता हूं। धन्यवाद। दुर्भाग्य से अब यह वास्तव में मार्टिन के रेटिना उत्तर का एक बंदरगाह है।
— edc65
^रेटिना में आवश्यक जो है - मुझे लगता है कि - डिफ़ॉल्ट रूप से सभी मैचों के लिए लग रहा है। लेकिन क्या हमें वाकई यहां इसकी जरूरत है?
— अरनुलद
@ अरनल्ड आप फिर से सही हैं
— edc65
-2:x=>(y=/.*?[aeiouy]+/i.exec(x)+' ')+y+x
— नादकोर
@ETHproductions वास्तव में। ध्यान देने के लिए धन्यवाद।
— edc65
12

बैच, 180 बाइट्स

@echo off
set/ps=
set v=aeiouy
set g=c
set t=
:l
call set w=%%v:%s:~,1%=%%
if %v%==%w% goto %g%
set g=o
:c
set t=%t%%s:~,1%
set s=%s:~1%
goto l
:o
echo %t% %t% %t%%s%

एक राज्य मशीन लागू करता है। gक्या हमने कभी एक स्वर देखा है, इस पर नज़र रखता है, इसलिए यदि वर्तमान पत्र एक स्वर नहीं है, तो हम जानते हैं कि क्या अगले पत्र के साथ आउटपुट करना या जारी रखना है।

— नील
स्रोत
12

पावरशेल , 46 47 41 39 38 बाइट्स

$args-replace"^.*?[aeiouy]+",(,'$&'*3)

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

बगफिक्स के लिए मॉर्टन बेमेलिस का धन्यवाद

रेनेंट के लिए 6 बाइट्स को सहेजा गया

सहेजा 2 जॉय के लिए 3 बाइट्स धन्यवाद

— ब्योर्न मोलेनमेकर
स्रोत
8

माणिक, 31 32 30 बाइट्स

->s{(s[/.*?[aeiouy]+/i]+' ')*2+s}

दो बाइट्स ने GB और Cyoce को धन्यवाद दिया।

— gntskn
स्रोत
6

PHP, 55 54 बाइट्स

नोट: एन्कोडेड संस्करण IBM-850 एन्कोडिंग का उपयोग करता है।

echo preg_filter("/^(.*?[aeiouy]+)/i","$1 $1 $0",$argn);
echo preg_filter(~ðíÎÐı└ñ×ÜûÉèåóÈÍðû,~█╬▀█╬▀█¤,$argn);     # Encoded

इस तरह से चलाएं:

echo "This isn't a single word." | php -nR 'echo preg_filter(~ðíÎÐı└ñ×ÜûÉèåóÈÍðû,~█╬▀█╬▀█¤,$argn);'

व्याख्या

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

बदलाव

  • उपलब्ध -Rकरने के लिए उपयोग करके एक बाइट को बचाया $argn(Thx टाइटस)
— aross
स्रोत
6

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

x=>(y=/.*?[aeiouy]+/i.exec(x)+' ')+y+x

f=
x=>(y=/.*?[aeiouy]+/i.exec(x)+' ')+y+x
<!-- snippet demo: -->
<input list=l oninput=console.log(f(this.value))>
<datalist id=l><option value=Land>
<option value=Moonlight>
<option value=queueing>
<option value="This isn't a single word.">
<option value="It's fun to play golf">
<option value=Ooo>
<option value="I'm okay.">
<option value="Hmm, no. There will be at least one vowel, but it can be anywhere.">
<option value="Why is y a vowel?">
स्निपेट का विस्तार करें

— nderscore
स्रोत
5

सी, 202 196 195 193 190 180

i,j,k,m,n;f(char*a){if((a[i/12]-"AEIOUY"[i++%6])%32==0)k=n=24-(i%12);else if(k&&!n--){m=j=(i-13)/12;for(i=0;i<j*2;)printf("%c%c",a[i%j],(i==j-1)*32),i++;printf(" %s", a);}m?:f(a);}

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

गोल्फ के लिए छोड़ दिया:

• एक में दो प्रिंटफ़ को संक्षिप्त करें।

• मेरे स्पेस चार की छपाई को %*cतर्क में बदला जा सकता है, मुझे यकीन है।

• मैं सशर्त का उपयोग कर रहा हूं जिसे किसी तरह हटाया जा सकता है

• j=(i-13)/12संभावना को छोटा किया जा सकता है।

• [ ==0अ ] सशर्त जाँच करता है कि जो आमतौर पर गैर-आवश्यक है, हालांकि मैं वर्तमान में उस एक पर अटका हुआ हूं (यदि कोई और स्विच करना चाहता है और ==0पूरी तरह से खाई की कोशिश करता है, लेकिन इसके लिए और अधिक {ब्रैकेट्स जोड़ने और बाइट का आकार बढ़ाने की आवश्यकता है)

ट्रिक्स मैं इसे नीचे गोल्फ करने के लिए इस्तेमाल किया है:

• x- अक्ष के लिए modulo और y- अक्ष (इनपुट स्ट्रिंग बनाम स्वर स्ट्रिंग) के लिए modulo का उपयोग करके लूप स्ट्रिंग खोज के लिए एक डबल संयुक्त। (X- अक्ष को y- अक्ष पर एक बार पुनरावृत्ति करने से पहले दो बार लूप किया जाता है; पहली बार [AZ] के साथ और दूसरी बार [az] चरित्र मान 32 अंतर का उपयोग करते हुए।

• चरित्र सेट और मोडुलो 32 के बीच की दूरी को ले कर "[आयु] और [ay]" का उपयोग करने के लिए बाईपास किया गया। यदि दूरी 0 (एए) है या यदि दूरी 32 (एए) है तो

• पूर्णांक चर का फिर से उपयोग करना जो अब बूलियन चर के रूप में उपयोग में नहीं हैं।

• पुन: इसके माध्यम से प्रक्रिया करने के लिए उसी स्ट्रिंग के साथ एक फ़ंक्शन कॉल करना और दूसरे फॉर-लूप से बचें।

• दूसरे चर को सेट करने के तर्क के लिए BOOL मान सेट करें। (उदाहरण बूल = i = 5;) एक पत्थर से दोनों को बाहर निकालने के लिए।

• तिर्यक खाली-सच्चा शोषण। (जीसीसी)

पठनीय प्रारूप:

i,j,k,m,n;
f(char*a){
    if((a[i/12]-"AEIOUY"[i++%6])%32==0)
        k=n=24-(i%12);
    else
        if(k&&!n--){
            m=j=(i-13)/12;
            i=0;
            for(;i<j*2;)
               printf("%c%c",a[i%j],(i==j-1)?32:0),i++;
            printf(" %s", a);
        }
    m?:f(a);
}

10 बाइट्स के साथ कीकू गण का धन्यवाद (टिप्पणियों में)

— अल्बर्ट रेनशॉ
स्रोत
स्वयं पर ध्यान दें: j=(i-13)/12संभावना को छोटा किया जा सकता है।
— अल्बर्ट रेनशॉ
क्या मुझे कुछ याद आ रहा है, या आप शुरू कर सकते हैं i=j=k=m=n=0;?
— रिचर्ड आयरन ने
@RichardIrons को पहले घोषित किया जाना था।
— अल्बर्ट रेनशॉ
आप i,j,k,m,n;आरंभीकरण के लिए उपयोग कर सकते हैं ।
— कीउ गण
@ केकय अपुष्ट व्यवहार, हमेशा के लिए 0. गारंटी नहीं है (जहाँ तक मुझे पता है?)
— अल्बर्ट रेनशॉ
4

MATL, 33 बाइट्स

'(^.*?[yY%s]+)'13Y2YD'$1 $1 $1'YX

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

व्याख्या

                % Implicitly grab input as a string
'(^.*?[yY%s]+)' % Push this string literal (regex pattern)
13Y2            % Push the string literal 'AEIUOaeiuo'
YD              % Replace the '%s' in the string with 'AEIUOaeiuo'
'$1 $1 $1'     % Push the string literal to use for replacement which repeats
                % the first match 3 times
YX              % Perform regular expression matching and replacement
                % Implicitly display the result
— Suever
स्रोत
'(^.*?[yY%s]+)'13Y2YD'$1 '8:)YX2 बाइट्स बचाता है
— लुइस मेंडो
'(^.*?[%s]+)'19Y2YD'$1 '8:)YXएक और 2 बचाता है
— बी मेहता
@ B.Mehta 19Y2मौजूद नहीं था जब इस उत्तर दुर्भाग्य से प्रस्तुत की गई थी
— Suever
हाँ, थोड़ा उम्मीद है कि उत्तर ... मैं अपनी टिप्पणी रखूँगा ताकि अन्य लोग इनबिल्ट शाब्दिक 'अईयौय' के बारे में भी जान सकें।
— बी। मेहता
@ बी.मेता कोई चिंता नहीं। MATL ऑनलाइन (matl.suever.net) के साथ आप शीर्ष दाईं ओर ड्रॉप-डाउन का उपयोग करके एक विशिष्ट संस्करण का चयन कर सकते हैं
— Suever
4

वी , 21 , 20 बाइट्स

é /ã[aeiouy]«“.
3ä|<

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

स्पष्टीकरण:

é               " Insert a space
  /             " Jump forward too...
   ã[aeiouy]«. "   The first non-vowel after a vowel
3ä              " Make three copies of
  |             " Everything from the cursor to the first character
   <            " Delete the space we inserted

Hexdump:

00000000: e920 2fe3 5b61 6569 6f75 795d ab93 2e0a  . /.[aeiouy]....
00000010: 33e4 7c3c                                3.|<

वैकल्पिक संस्करण (21 बाइट्स):

Í㨃[aeiouy]«©/± ± &

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

यह हास्यास्पद रेगेक्स संपीड़न का उपयोग करता है, और यह अभी भी अन्य गोल्फ भाषाओं द्वारा लात मारी गई बट पाने के लिए प्रबंधित करता है। संदर्भ के लिए, यह दो / तिहाई नियमित "असम्पीडित" संस्करण की लंबाई के बारे में है, अर्थात्:

:%s/\v\c(.{-}[aeiou]).*/\1 \1 &

स्पष्टीकरण:

Í                               " Replace on every line:
 ã                              "   Case-insensitive
  ¨              ©              "   Capture-group 1
   <131>                        "   Any character, any number of times (non-greedy)
        [aeiouy]«               "   A vowel, repeated once or more
                  <129>         "   Followed by anything
                       /        " Replaced with:
                        ± ±     "   Capture group one twice, with spaces between
                            &   "   The whole matched pattern

यहाँ एक हेक्सडम्प है:

00000000: cde3 a883 5b61 6569 6f75 795d aba9 812f  ....[aeiouy].../
00000010: b120 b120 26                             . . &
— DJMcMayhem
स्रोत
2
+1 यह अब तक का सबसे प्रभावशाली वी रेगेक्स सबमिशन है जिसे मैंने देखा है
— गाय
— nmjcman101
4

पायथन 3 , 75 68 बाइट्स

lambda s:(s[:[x in"aAeEiIoOuUyY"for x in s][1:].index(0)+1]+" ")*2+s

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

स्पष्टीकरण:

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

— Trelzevir
स्रोत
4

क्लोजर, 192 188 181 बाइट्स

(fn[p](let[[f] p v #(#{\a \e \i \o \u \y}(Character/toLowerCase %))[q r](split-with(if(v f)v #(not(v %)))p)[w _](split-with v r)as #(apply str %)](str(as(repeat 2(str(as q)(as w) \ )))p)))

-4 बाइट्स इनलाइनिंग first-sp-pred(व्हूप्स) द्वारा।

-7 बाइट्स में कुछ मिस्ड स्पेस हटाकर

यह कहीं अधिक चुनौतीपूर्ण था जितना मैंने सोचा था कि यह अंदर जाएगा! मैं मैन्युअल रूप से स्ट्रिंग पार्स कर रहा हूँ ... क्योंकि मैं अभी भी regex सीखने के लिए आस-पास नहीं गया हूं: /

ब्रेकडाउन के लिए पूर्व-गोल्फ कोड देखें:

(defn repeat-prefix-cons [phrase]
  (let [[first-letter] phrase ; Get first letter

        ; Function that checks if a lowercased character is a part of the vowel set
        vowel? #(#{\a \e \i \o \u \y} (Character/toLowerCase %))

        ; cons(onant)? Negation of above
        cons? #(not (vowel? %))

        ; Decide how to split it depending on if the first character is a vowel
        first-sp-pred (if (vowel? first-letter) vowel? cons?)

        ; Split off the first chunk of cons/vowels
        [pre1 r] (split-with first-sp-pred phrase)

        ; Split off the rest of the vowels
        [pre2 r2] (split-with vowel? r)

        ; Shortcut function that turns a list into a string (Basically (join "" some-list-of-strings) )
        as #(apply str %)]

    (str ; ... then concat the prefix in front of the original phrase, and return
      (as ; ...then turn it back into a string since "repeat" returns a list... ^
        (repeat 2 ; ... then repeat it twice (shame Clojure doesn't have string multiplication)... ^
                (str (as pre1) (as pre2) \ ))) ; Concat the 2 prefix parts together with an space at the end... ^
      phrase)))
— Carcigenicate
स्रोत
4

पायथन 3 , 101 96 बाइट्स

s=input()
v=i=0
for c in s:
 w=c in'aAeEiIoOuUyY'
 if v*~-w:break
 v=w;i+=1
print(s[:i],s[:i],s)

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

एक गैर-रेगेक्स समाधान

टिप्पणी की:

s=input()
a='aAeEiIoOuUyY'
v=i=0
for c in s:          # for each character in the string
 w=c in a            # w = True if the character is a vowel, else false
                     # true is equivalent to 1  and false to zero
                     # v*(w-1) evaluates only to true (-1 in this case) if v=1 (last character was a vowel) and w=0 (current character is not a vowel)
 if v*(w-1):break    # if so, break the loop
 v=w;i+=1            # increase the counter and set v to w
print(s[:i],s[:i],s)
— OVS
स्रोत
आपको एक की आवश्यकता क्यों है? बदलें w=c in aके साथw=c in'aAeEiIoOuUyY'
— sagiksp
4

ओम , 19 बाइट्स (CP437), गैर-प्रतिस्पर्धात्मक

नई भाषा, और इस तरह, मुझे इस काम को करने के लिए कुछ नई विशेषताओं को जोड़ना पड़ा, जो दुख की बात है कि यह गैर-प्रतिस्पर्धी है (क्योंकि कमियां)।

≡┬üC▓αy_ε;TF«u├DQüj

स्पष्टीकरण:

≡┬üC▓αy_ε;TF«u├DQüj     Main wire, arguments: s

≡                       Triplicate input
 C                    Push input, all lowercase with concatenated space character
    ▓    ;              Map string into an array with...
     αy_ε                 Boolean: is element a vowel?
          TF«u          Find first occurrence of [true, false]
              ├D        Slice input up to that index and duplicate it
                Q       Reverse stack
                 üj     Join on spaces, implicitly print
— निक क्लिफोर्ड
स्रोत
मैं यह जानने के लिए उत्सुक हूं कि आपने कौन सी सुविधाएँ लागू की हैं ...?
— स्टिव ग्रिफ़िन
@StewieGriffin स्टैक उत्क्रमण ( Q), सबर्रे सर्चिंग ( u), स्ट्रिंग / एरे स्लाइसिंग ( ├), और स्वर स्थिरांक ( αvऔर αy)।
— निक क्लिफर्ड
4

PHP, 69 65 53 बाइट्स

<?=preg_filter("#.*?[aeiouy]+#i","$0 $0 $0",$argn,1);

PHP 5.3 या बाद के संस्करण की आवश्यकता है। ऑनलाइन कुछ संस्करणों के साथ पाइप के रूप में चलाएं -Fया प्रयास करें ।

@Aross से चोरी किए गए रेगेक्स के साथ 4 बाइट्स (और कोड को ठीक किया गया) सहेजा गया;
के साथ 10 से अधिक preg_filterके बजाय preg_matchऔर -F
और एक बेहतर regex के साथ एक और दो।

गैर-रेगेक्स संस्करण के लिए 75 81 बाइट्स :

for(;$c=$argn[$i++];)($k+=$k^!trim($c,aeiouyAEIOUY))>1?:$w.=$c;echo"$w $w $argn";

PHP 5 या बाद के संस्करण की आवश्यकता है; पुराने PHP के ?:साथ बदलें ?1:। साथ दौड़ो-nR

टूट - फूट

for(;$c=$argn[$i++];)       // loop $c through input characters
    ($k+=$k^!                   // 2. !$k and vowel or $k and not vowel: increment $k
        trim($c,aeiouyAEIOUY)   // 1. strip vowels -> vowel=false, non-vowel=true
    )>1                         // 3. if $k>1
    ?                           // do nothing
    :$w.=$c;                    // else append $c to $w
echo"$w $w $argn";          // output
— टाइटस
स्रोत
काम करने के लिए प्रकट नहीं होता है। बाहर के लिए डाल दिया This isn't a single word:T T This isn't a single word.
— aross
@ सकल लगता है कि यह सिर्फ लोअरकेस मान की जाँच कर रहा है? मैं गलत हो सकता है मैं PHP कि अच्छी तरह से नहीं जानता
— अल्बर्ट Renshaw
1
@AlbertRenshaw रेगेक्स संस्करण iसंशोधक का उपयोग करता है जो रेगेक्स केस को असंवेदनशील बनाता है। अन्य एक संस्करण ने केवल लोअरकेस की जांच की। फिक्स्ड।
— टाइटस
4

आर, 49bytes

sub("(.*?[aeiouy]+)","\\1 \\1 \\1",scan(,""),T,T)

रेगेक्स आधारित प्रतिस्थापित करें, एक स्वर तक सब कुछ मैच करें, 3 बार कैप्चर करें और इसे स्वयं बदलें।

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

Tके लिए खड़ा है TRUEऔर 4 और उप करने के लिए 5 वीं पैरामीटर मामले को अनदेखा करें और PCRE उपयोग करने के लिए यह बताने के लिए के रूप में कुछ चार बचाने (greedyness आर regex वाक्य रचना के साथ ही नहीं है)

4 बाइट्स ने रनिंग कोड के लिए Tio लिंक के साथ Sumner18 के सौजन्य से बचाया

— Tensibai
स्रोत
3

जावा 8, 147 140 बाइट्स

golfed:

import java.util.regex.*;s->{Matcher m=Pattern.compile("([^aeiouy]*[aeiouy]+)",2).matcher(s);m.find();return m.group()+" "+m.group()+" "+s;}

Ungolfed:

import java.util.regex.*;

public class LaLaLandNoWaitMooMooMoonlight {

  public static void main(String[] args) {
    for (String[] strings : new String[][] { { "Land", "La La Land" }, { "Moonlight", "Moo Moo Moonlight" },
        { "queueing", "queuei queuei queueing" }, { "This isn't a single word.", "Thi Thi This isn't a single word." },
        { "It's fun to play golf", "I I It's fun to play golf" }, { "Ooo", "Ooo Ooo Ooo" },
        { "I'm okay", "I I I'm okay" }, { "Hmm, no. There will be at least one vowel, but it can be anywhere.",
            "Hmm, no Hmm, no Hmm, no. There will be at least one vowel, but it can be anywhere." } }) {
      final String input = strings[0];
      final String expected = strings[1];
      final String actual = f(s -> {
        java.util.regex.Matcher m = java.util.regex.Pattern.compile("([^aeiouy]*[aeiouy]+)", 2).matcher(s);
        m.find();
        return m.group() + " " + m.group() + " " + s;
      } , input);
      System.out.println("Input:    " + input);
      System.out.println("Expected: " + expected);
      System.out.println("Actual:   " + actual);
      System.out.println();
    }

  }

  private static String f(java.util.function.Function<String, String> function, String input) {
    return function.apply(input);
  }
}

नोट: शाब्दिक 2कोड में का मूल्य है java.util.regex.Pattern.CASE_INSENSITIVE।

2
मुझे लगता है कि आप import java.util.regex.*;कुछ बाइट्स को बचाने के लिए उपयोग कर सकते हैं ।
— रोमन ग्रफ
@ RomanGräf आप सही हैं। मेरे पास संकुल था क्योंकि कोड के पुराने संस्करण में (काम नहीं किया) यह आयात का उपयोग नहीं करने के लिए कम था। कोड तय करने के बाद मैंने पुनर्मूल्यांकन नहीं किया।
3

सी, 123 बाइट्स

#define v(x)while(x strchr("AEIOUY",*s&95))++s;
a;f(s,t)char*s,*t;{t=s;v(!)v()a=*s;*s=0;printf("%s %s ",t,t);*s=a;puts(t);}

इस रूप में कॉल करें:

main(){char s[] = "queueing"; f(s);}
— लिन
स्रोत
1
यह अच्छा है! आपने पार्क सी से मेरा सी समाधान बाहर खटखटाया।
— अल्बर्ट रेनशॉ
2

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

i1`.*?[aeiouy]+
$0 $0 $0

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

— mbomb007
स्रोत
काफी के समान इस
— Emigna
हाँ मुझे पता है। लेकिन मैंने स्वतंत्र रूप से उत्तर दिया। फिर भी, यह निर्णय लिया गया है कि यदि काम की प्रतिज्ञा नहीं की गई है, तो डुप्लिकेट उत्तरों की अनुमति दी जाती है।
— mbomb007
2

पायथन 3 , 130 102 बाइट्स

w=input();a='';v=0
for i in w:
	if i in 'aeiouyAEIOUY': v=1
	elif v:
		break
	a+=i
a+=' ';print(a*2+w)

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

किसी भी प्रकार का कोई फ़ंक्शन और कोई बाहरी पुस्तकालयों का उपयोग नहीं करता है! (जब तक प्रिंट और इनपुट कार्य के रूप में गणना नहीं करते, जो वे करते हैं)।

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

28 बाइट्स @LliwTelracs के लिए धन्यवाद सहेजा गया

— कॉमरेड स्पार्कलपनी
स्रोत
2

MATLAB / ऑक्टेव, 58 51 बाइट्स

7 बाइट्स ने @HughNolan को धन्यवाद दिया

@(x)regexprep(x,'(^.*?[aeiouyAEIOUY]+)','$1 $1 $1')

एक अनाम फ़ंक्शन बनाता ansहै जिसे एक स्ट्रिंग पास करके बुलाया जा सकता है:ans('Land')

ऑनलाइन डेमो

MATLAB संगतता के लिए, उपरोक्त फ़ंक्शन के $0स्थान पर उपयोग किया जाना चाहिए $1।

— Suever
स्रोत
इस बारे में सोच रहा था और फिर देखा कि आपने यह पहले ही कर लिया था। कुछ बाइट्स बचाएं: @(x)regexprep(x,'^.*?[aeiouyAEIOUY]+','$0 $0 $0 ');- मैटलैब $ 1 के बजाय $ 0 का उपयोग करने के लिए अजीब लगता है
— ह्यूग नोलन
@HughNolan महान बिंदु, धन्यवाद!
— सूअर
2

सी (जीसीसी) , 111 110 बाइट्स

*d="AEIOUYaeiouy";b;f(char*a){b=strcspn(a,d);write(printf(" "),a,write(1,a,b+strspn(a+b,d)));printf(" %s",a);}

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

यह सिर्फ लाइब्रेरी फ़ंक्शंस का उपयोग करता है strspn()और strcspn()फ़ंक्शन के मापदंडों का मूल्यांकन करने वाले ऑर्डर का शोषण करता है। थोड़ा कम गोल्फ

*d="AEIOUYaeiouy";b;
f(char*a){
  b=strcspn(a,d);
  write(printf(" "),a,write(1,a,b+strspn(a+b,d)));
  printf(" %s",a);
}

शुक्रिया @gastropner -1 के लिए।

— ceilingcat
स्रोत
वाह!! अच्छा काम!
— अल्बर्ट रेनशॉ
— गैस्ट्रोपनर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.