कभी #brexit या #brangelina जैसे कूल ट्विटर हैशटैग बनाने वाले ? यह गोल्फ आपके लिए है।

एक प्रोग्राम लिखें जो दो स्ट्रिंग्स A & B को इनपुट के रूप में स्वीकार करता है और उन्हें निम्न एल्गोरिथम के अनुसार मर्ज करता है:

nA में स्वर समूहों की संख्या होने दें (जैसे britain2 स्वर समूह हैं: iस्थिति 3 में और aiस्थिति 5 में)।
- अगर n = 1: अपने पहले स्वर समूह की स्थिति में एक शुरुआत को छोटा करें (उदाहरण: bill=> b)
- यदि n> 1: अपने n-1वें स्वर समूह की स्थिति में एक शुरुआत को छोटा करें (उदाहरण: programming=> progr, britain=> br)
B ( jennifer=> ennifer) की शुरुआत में सभी व्यंजन निकालें
संशोधित A & B को परिवर्तित करें

स्वर हैं aeiou; व्यंजन हैं bcdfghjklmnpqrstvwxyz।

इनपुट

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

उदाहरण

brad + angelina      => brangelina
britain + exit       => brexit
ben + jennifer       => bennifer
brangelina + exit    => brangelexit
bill + hillary       => billary
angelina + brad      => angelad
programming + puzzle => progruzzle
code + golf          => colf
out + go             => o

code-golf

— अरनॉड
स्रोत

65

नया टेस्ट केस? donald trump।

— स्टीवी ग्रिफिन

5

ये अनिवार्य रूप से पोर्टमिंटियस हैं ।

— mbomb007

3

सम्बंधित

— ETHproductions

1

@ETHproductions यह बहुत अलग संयोजनों का उत्पादन करने के लिए लगता है, जैसे किDjango + Angular = Djular

— प्यूरफेरेट

"N-1

— वां

24

रूबी, 44 43 40 + 1 = 41 बाइट्स

-pझंडे के लिए +1 बाइट । एसटीडीआईएन पर अंतरिक्ष-पृथक इनपुट लेता है।
-1 बाइट मार्टिन
एंडर के लिए धन्यवाद -2 बाइट्स हिस्टोक्रेट के लिए धन्यवाद

sub /([aeiou]+([^aeiou]*)){,2} \g<2>/,""

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

GNU sed, 39 37 + 1 = 38 बाइट्स

-Eझंडे के लिए +1 बाइट । एसटीडीआईएन पर अंतरिक्ष-पृथक इनपुट लेता है।
मार्टिन एंडर के लिए -1 बाइट धन्यवाद

s/([aeiou]+[^aeiou]*){,2} [^aeiou]*//

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

इसे अलग उत्तर के रूप में पोस्ट नहीं करना क्योंकि यह वस्तुतः एक ही समाधान है।

— जॉर्डन
स्रोत

अच्छा regex! यदि मैं अपने जेएस उत्तर में इसका उपयोग करता हूं तो मन?

— 3

ज़रूर, पागल हो जाओ।

— जॉर्डन

3

आप [^aeiou]/([aeiou]+([^aeiou]*)){,2} \g<2>/

— सबजिपिक्स

5

— क्रोस

1

@ अको इस उत्तर में "विशेष आह्वान" देखें । TL; DR: केवल डिफ़ॉल्ट आमंत्रण के अलावा बाइट्स की गणना करें। रूबी के लिए डिफ़ॉल्ट मंगलाचरण है ruby -e "..."। इसके लिए यह है ruby -pe "...", इसलिए यह केवल एक बाइट जोड़ता है।

— जॉर्डन

12

MATL, 31 30 बाइट्स

t13Y2XJmFwhdl=fql_):)itJmYsg)h

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

व्याख्या

t       % Implicitly grab the input and duplicate it
13Y2    % Push the string literal 'aeiouAEIOU'
XJ      % Store this in clipboard J for later use
m       % Check which characters from the input are vowels (true for vowel)
Fwh     % Prepend FALSE to this logical array
dl=     % Compute the difference and find where we went from not-vowel to vowel
f       % Find the indices of these transitions
q       % Subtract 1 to get the location of the last consonant in each transition
l_)     % Get the next-to-last one of these
:)      % Grab the first string up to this location

% Now for the second component!

it      % Explicitly grab the input and duplicate
J       % Retrieve the string literal 'aeiouAEIOU' from clipboard J
m       % Find where the vowels are (true for vowel)
Ys      % Compute the cumulative sum along the array. The result will be 0
        % for all characters before the first vowel and non-zero after
g)      % Convert to logical and use this as an index so any characters
        % after the first value are retrieved

% Now to combine them

h       % Horizontally concatenate the first and second pieces together
        % Implicitly display the result

— Suever
स्रोत

1

मैं हमेशा खुश कोड को बढ़ाता हूं

— एंड्रास डीक

12

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

सहेजे गए 8 बाइट्स @Jordan, 1 धन्यवाद @DavidConrad के लिए

a=>b=>a.match(/.*?(?=(?:[aeiou]+[^aeiou]*){1,2}$)/)+b.match(/[aeiou].*/)

भले ही .matchएक सरणी array+arrayदेता है , संक्षिप्त (यानी [0]+[1]रिटर्न "01") की सामग्री के साथ एक स्ट्रिंग देता है ।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

f=a=>b=>console.log(a,"+",b,"=",a.match(/.*?(?=(?:[aeiou]+[^aeiou]*){1,2}$)/)+b.match(/[aeiou].*/))
f("brad")("angelina")
f("britain")("exit")
f("ben")("jennifer")
f("brangelina")("exit")
f("bill")("hillary")
f("angelina")("brad")
f("programming")("puzzle")
f("code")("golf")
f("progruzzle")("colf")
f("out")("go")

<input id=A value="super">
<input id=B value="chafouin">
<button onclick="f(A.value)(B.value)">Run</button>

स्निपेट का विस्तार करें

जेएस में जॉर्डन का उत्कृष्ट रूबी समाधान 53 बाइट्स होगा:

x=>x.replace(/([aeiou]+[^aeiou]*){1,2} [^aeiou]*/,"")

— ETHproductions
स्रोत

हो सकता है कि सिर्फ मैच बिट बाहर फेंक सकते हैं और एक प्रतिस्थापन का उपयोग कर सकते हैं?

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

@ ConorO'Brien जोर्डन को लगता है कि जॉर्डन का जवाब चुरा रहा है: /

— ETHproductions

आपने सचमुच मेरा मन पढ़ लिया। और हाँ, यह सच है

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

1

1 बाइट बचाने के (a,b)=>लिए करी a=>b=>।

— डेविड कॉनरेड

7

जेली , 23 22 बाइट्स

e€ØcT
Çµḟ‘-ị’
Ç⁸ḣ⁹ÑḢ⁹ṫ

TryItOnline

कैसे?

e€ØcT    - Link 1, vowel indexes: s   e.g. "colouring"
  Øc     - yield vowels, "AEIOUaeiou"
e€       - in for each                     [0,1,0,1,1,0,1,0,0]
    T    - truthy indexes (1-based)        [2,4,5,7]

Çµḟ‘-ị’  - Link 2, n-1th or only vowel group index start - 1: s
 µ       - monadic chain separation
Ç        - call last link (1) as a monad   [2,4,5,7]
   ‘     - increment                       [3,5,6,8]
  ḟ      - filter out                      [2,4,7]
    -    - -1
     ị   - index value                     [4]
               (Jelly is 1-based and has modular indexing,
                so the last but one item is at index -1,
                and when there is only 1 item in the list it is also at index -1)
      ’  - decrement                       [3]

Ç⁸ḣ⁹ÑḢ⁹ṫ - Main link: a, b                      e.g. "colouring", "pencils"
Ç        - call last link (2) as a monad with a      [3]
 ⁸       - link's left argument, a
  ḣ      - head a[:y]                                "col"
   ⁹  ⁹  - link's right argument, b
    Ñ    - call next link (1) as a monad                          [2,5]
     Ḣ   - pop head                                               [2]
       ṫ - tail b[y-1:]                                           "encils"
         - implicit print                            "colencils"

— जोनाथन एलन
स्रोत

खूबसूरती से समझाया!

— शुद्ध

5

PowerShell v2 +, 76 बाइट्स

param($n,$m)($n-replace'([aeiou]+[^aeiou]*){1,2}$')+($m-replace'^[^aeiou]*')

जाहिरा तौर पर यह एक लोकप्रिय regex है ... ;-)

-replaceउपयुक्त टुकड़ों को खींचने के लिए ऑपरेटर का उपयोग करता है , फिर स्ट्रिंग-परिणाम को एक साथ जोड़ता है। एक पर जोड़ता है $पहले करने के लिए सुनिश्चित करने के लिए हम स्ट्रिंग के अंत खींच, और एक कहते हैं ^सुनिश्चित करने के लिए हम स्ट्रिंग के सामने हटा दूसरे को।

— AdmBorkBork
स्रोत

4

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

([aeiou]+[^aeiou]*){1,2} [^aeiou]*

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

बस पहली पंक्ति पर रेगेक्स के सभी मैचों को हटा देता है।

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

1

स्वर और गैर-स्वर वर्ग को जोड़ने की कोई योजना है? ;-)

— ETHproductions

@ETHproductions यदि मैं कभी भी अपने स्वयं के रेगेक्स स्वाद को लागू करने के लिए परेशान हो सकता हूं (या कम से कम इसे टोकन कर सकता हूं ताकि इसे .NET रेगेक्स में स्थानांतरित किया जा सके), निश्चित रूप से! : पी

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

रूबी पैटर्न बैकरेफेरेंस कर सकती है (वही पैटर्न जो पात्रों के एक अलग क्रम से मेल खा सकता है)। ये यहां उपयोगी होंगे। उदाहरण के लिए, मैचिंग कोष्ठकों का मिलान /^(($\g<1>$)*)$/रूबी द्वारा किया जाता है।

— जॉन ड्वोरक

1

@JanDvorak बहुत बुरा रेटिना .NET, हुह में लिखा है? ;) मैंने इसे github.com/ltrzesniewski/pcre-net के साथ बंडल करने पर विचार किया ताकि आप जायके को स्विच कर सकें, लेकिन अभी तक इसके आस-पास नहीं पहुंचे , और कुछ अन्य विशेषताएं तेजी से .NET- विशिष्ट मिलान व्यवहार पर निर्भर हैं।

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

1

समय .net विशिष्ट व्यवहार छोड़ने के लिए और रूबी में सब कुछ फिर से लिखना? रूबी कहीं भी बेहतर है :-)

— जॉन ड्वोरक

4

दालचीनी गोंद, 23 बाइट्स

0000000: 64d3 884e 4ccd cc2f 8dd5 8e8e 8330 b434  d..NL../.....0.4
0000010: b108 d92b c0d9 00                        ...+...

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

व्याख्या

यह करने के लिए decompresses d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*, जो dकि regex मिलान कुछ भी eletes। (ध्यान दें कि d([aeiou]+[^aeiou]*){,2} [^aeiou]*बार-बार तत्वों को संपीड़ित करने की कमी के कारण जॉर्डन का गोल्फर 24 बाइट्स तक संकुचित हो जाता है।)

— एक स्पैगेटो
स्रोत

d[aeiou]+[^aeiou]*[aeiou]*[^aeiou]* [^aeiou]*कोई छोटा होगा ?

— ETHproductions

@ETHproductions मैंने कोशिश की कि, यह एक ही बाइट काउंट था :(

— एक

3

PHP, 95 बाइट्स

$t="aeiou]";echo($p=preg_filter)("#([$t+[^$t*){1,2}$#","",$argv[1]).$p("#^[^$t*#","",$argv[2]);

प्रीग_फिल्टर के बजाय प्रीग_फिल्टर 110 बाइट्स के साथ

$t="aeiou]";($p=preg_match)("#(.*?)([$t+[^$t*){1,2}$#",$argv[1],$m);$p("#[$t.*#",$argv[2],$n);echo$m[1].$n[0];

— जार्ग हुल्सरमैन
स्रोत

1

आप उपयोग कर सकते हैं +के बजाय {1,2}।

— टाइटस

@ अधिक महत्वपूर्ण बात 1 केस के लिए बग को खत्म करना था और अब मैं इसे नीचे गिराने की कोशिश कर सकता हूं

— Jörg Hülsermann

$v=aeiou;3 और बचाने के लिए उपयोग करें ।

— टाइटस

@ टिट्स मेरे पास एक ही विचार था लेकिन थोड़ा संस्करण के साथ। धन्यवाद

— Jörg Hülsermann

3

लुआ, 66 बाइट्स

$ cat merge.lua
print(((...):gsub(("[]+[^]*[]*[^]*+[^]*"):gsub("]","aeiou]"),"")))
$ lua merge.lua brad+angelina
brangelina
$ lua merge.lua programming+puzzle
progruzzle

— ईगोर स्क्रीप्टुनॉफ
स्रोत

2

पर्ल 5, 39 बाइट्स

-peइसके बजाय 38, प्लस 1-e

s/([aeiou]+[^aeiou]*){1,2} [^aeiou]*//

टोपी की नोक।

— msh210
स्रोत

उसी के रूप में भीतर से जुड़ा हुआ है, लेकिन हम पर्ल में भी इसका जवाब दे सकते हैं।

— msh210

2

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

n=lambda a,b:a[:a.index(([l for l in[[l,"!"][i!=0and a[i-1]in v]for i,l in enumerate(a)]if l in v]*2)[-2])]+b[sorted([(b+v).index(c)for c in v])[0]:]

यह एक कठिन था।

इसे repl.it पर देखें

— Quelklef
स्रोत

2

लिथप , 65 बाइट्स

#X::((replace X (regex "([aeiou]+[^aeiou]*){1,2} [^aeiou]*") ""))

यह मूल रूप से मेरी Lisp-ish कार्यात्मक प्रोग्रामिंग भाषा में, ऊपर दिए गए जावास्क्रिप्ट उत्तर का एक बंदरगाह है।

उदाहरण का उपयोग:

(
    % Note, you can define this as a function, or assign it to a variable
    % and use the call function instead.
    (def f #X::((replace X (regex "([aeiou]+[^aeiou]*){1,2} [^aeiou]*") "")))
    (print (f "programming puzzle"))
)

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

इसके बजाय, यह पहेली समाधान मेरी भाषा के लिए एक उदाहरण के रूप में लागू किया गया है। इसे निम्न कमांड से चलाया जा सकता है:

node run.js l_src/progruzzle-colf.lithp

— Andrakis
स्रोत

2

हास्केल, 111 108 बाइट्स

v x=elem x"aeiou"
d=dropWhile
e=d v
k=d$not.v
r=reverse
f a|c<-e.k.e.k$a,""/=c=c|1<3=e.k$a
a!b=(r.f.r)a++k b

यह गैर-रेगेक्स समाधान उम्मीद से अधिक निकला। वैसे भी Ideone।

— Laikoni
स्रोत

1

Jq 1.5 , 45 बाइट्स

gsub("([aeiou]+[^aeiou]*){1,2} [^aeiou]*";"")

कुछ खास नहीं, बस jq की PCRE को msh210 के पर्ल समाधान का एक बंदरगाह ।

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

— jq170727
स्रोत

1

जाप , 18 बाइट्स

r/\v+\V*){1,2} \V*

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

लघु जेएस समाधान का प्रत्यक्ष बंदरगाह जो जॉर्डन के रूबी समाधान के बंदरगाह को चालू करता है ।

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

Ur/\v+\V*){1,2} \V*/

Ur    Replace on the input...
/\v+\V*){1,2} \V*/  this regex with empty string.
      \v == [AEIOUaeiou], \V == [^AEIOUaeiou], `g` flag is on by default in Japt
      so the uncompressed regex is roughly /([aeiou]+[^aeiou]*){1,2} [^aeiou]*/g.

— bubbler
स्रोत

Progruzzle और Colf

इनपुट

उदाहरण

रूबी, 44 43 40 + 1 = 41 बाइट्स

GNU sed, 39 37 + 1 = 38 बाइट्स

MATL, 31 30 बाइट्स

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

टेस्ट स्निपेट

जेली , 23 22 बाइट्स

PowerShell v2 +, 76 बाइट्स

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

दालचीनी गोंद, 23 बाइट्स

व्याख्या

PHP, 95 बाइट्स

लुआ, 66 बाइट्स

पर्ल 5, 39 बाइट्स

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

लिथप , 65 बाइट्स

हास्केल, 111 108 बाइट्स

Jq 1.5 , 45 बाइट्स

जाप , 18 बाइट्स

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