शब्दों का उच्चारण करें

50

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

plaster man -> master plan
blushing crow -> crushing blow
litigating more -> mitigating lore
strong wrangler -> wrong strangler
def ghi -> ghef di
few years -> yew fears

पहले स्वर ( aeiou) के सामने आने वाले व्यंजन स्विच किए जाते हैं।

इनपुट: दो लोअरकेस स्ट्रिंग्स जो विभिन्न व्यंजन के साथ शुरू होते हैं और प्रत्येक में एक स्वर होता है aeiou।

आउटपुट: दो स्पूनराइज्ड स्ट्रिंग्स, सही क्रम में।

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

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

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

code-golf  string 
— XNOR
स्रोत
4
शब्द व्यंजन से शुरू होते हैं।
— xnor
21
उत्तर "oozing snotter"imo ~ होना चाहिए
— पैट्रिक रॉबर्ट्स
3
@ पैट्रिक रॉबर्ट्स मैं सहमत हूं, लेकिन यह चुनौती को थोड़ा सरल बनाता है।
— xnor
1
विषय पर बहुत नहीं है, लेकिन एक अच्छा उदाहरण बर्फ परत -> प्रवाह सांप
— दोष
1
उपवास के भाग्य और कोय बंट को भाग लेने की अनुमति नहीं है
— डेनहेम कोट

जवाबों:

50

विम, 18 कीस्ट्रोक्स

/[aeiou]<CR>dbwvnhp0P

महत्वपूर्ण चाल यह है कि दृश्य मोड में किसी चीज़ पर चिपकाने से वास्तव में दृश्य चयन की पुरानी सामग्री पेस्ट बफर में डाल दी जाती है।

— orlp
स्रोत
... ओह, दोह, ऐसा नहीं सोचा था। vसमावेशी होने से फेंक दिया गया और वापस स्वर से चयन करने का प्रयास किया गया।
— दरवाज़े
10
एक आकस्मिक विम उपयोगकर्ता के रूप में, मैं चकित रह गया क्योंकि मैंने प्रत्येक क्रम को टाइप किया
— हारून
4
<CR> का मतलब है गाड़ी वापसी (पुराना टाइपराइटर टर्म!), जिसे एंटर के नाम से भी जाना जाता है
— काई कार्वर
22

ब्रेनफक, 238 207 बाइट्स

,[[<+<+>>-]++++[<-------->-]-[<<-->>-----]<<+++++[----[----[------[------>>]]]]>[>>]>,]<<++++++++[<[++++<<]<++++<[++++<<]>>[>>]>>[>>]<-]<[<<]-[<+>---]>[>.>]<[<<]<<[<<]>[>>]>[.>>]<.<[<<]>[>.>]>[>>]>[>>]>[.>>]

,EOF पर 0, 8-बिट रैपिंग सेल और सेल 0 से लेफ्ट ले जाने की क्षमता को वापस करने की आवश्यकता है। मेरे अनुभव में, ये सबसे सामान्य डिफ़ॉल्ट सेटिंग्स हैं।

मैं इससे बहुत खुश हूं। मेरी पहली कोशिश 314 बाइट्स थी और यह निश्चित रूप से एक सुधार है। :)

यह हर बाइट को दो कोशिकाओं में इनपुट से स्टोर करके काम करता है; एक बाइट के वास्तविक मूल्य के साथ और दूसरा निम्न कोड के आउटपुट के साथ जब दिया जाता है (बाइट का मूल्य - 97):

[
    ----
    [
        ----
        [
            ------
            [
                ------>>
            ]
        ]
    ]
]

यदि वर्ण एक व्यंजन है, तो यह शून्य मान के साथ आता है। यदि यह एक स्वर है, तो यह 0. हो जाता है। वहां से यह केवल खोजने का मामला है जहां दूसरा शब्द शुरू होता है और क्रम में सब कुछ प्रिंट करता है।

इस कार्यक्रम के 238 बाइट संस्करण ने सभी इनपुट एकत्र करने के बाद अंतरिक्ष चरित्र पाया। यह एक सिरदर्द था क्योंकि ऐसा करने से एक सेल बनती थी जिसमें 0 सही होता था जहाँ मैं उस पर लूप करने की कोशिश कर रहा था। जिस तरह से मैंने हल किया वह पहले शब्द में प्रत्येक वर्ण से 30 घटाना और उसके बाद प्रत्येक वर्ण से 32 का प्रभाव था। कोड का एक बड़ा हिस्सा उस बकवास से निपटने के लिए समर्पित था।

अब, इनपुट लूप में प्रत्येक वर्ण से 32 घटाया गया है , जो छोटा है और इसका एक समान दुष्प्रभाव है जिससे निपटना आसान है। एक बोनस के रूप में, इस तरह से करने से मुझे एक छोटे तरीके से अपना खुद का अंतरिक्ष चरित्र बनाने की अनुमति मिली: 171 से 139 घटने के बजाय (171 वह है जो आपको तब मिलता है जब आप ऊपर दिए गए स्वर डिटेक्टर के माध्यम से एक जगह चलाते हैं), 32 को जोड़ने वाला लूप हर पात्र 32 से 171 सेल में भी जुड़ जाता है। यह चार बाइट्स की लागत है, लेकिन इसका मतलब है कि मैं 171 घटा सकता हूं बाद में (139 को घटाने के बजाय) कुल 3 बाइट्स बचा सकता है।

टिप्पणियों के साथ:

For every input character
,[

  Make a copy
  [<+<+>>-]

  Subtract 32 from one
  ++++[<-------->-]

  Subtract 97 from the other
  -[<<-->>-----]<<+++++

  If nonzero:
  [

    Subtract 4
    ----

    If nonzero:
    [

      Subtract 4
      ----

      If nonzero:
      [

        Subtract 6
        ------

        If nonzero:
        [

          Subtract 6
          ------>>

        ]

      ]

    ]

  ]

>[>>]>,]

Add 32 to every character and the 171 that the space left behind
<<++++++++[<[++++<<]<++++<[++++<<]>>[>>]>>[>>]<-]

Go to the space
<[<<]

Subtract 171 from (32 plus 171)
-[<+>---]

~~~~~~~~~~~~~~~

Ready to print!

~~~~~~~~~~~~~~~

Print letters from the second word until the value to the left is zero
>[>.>]

Go to the beginning of the first word
<[<<]<<[<<]

Look at cells to the left of letters in the first word until reaching a zero
>[>>]

Print the rest of the letters in the first word
>[.>>]

Print a space
<.

Go to the beginning of the first word
<[<<]

Print letters from the first word until the value to the left is zero
>[>.>]

Go to the beginning of the second word
>[>>]

Look at cells to the left of letters in the second word until reaching a zero
>[>>]

Print the rest of the letters in the second word
>[.>>]
— undergroundmonorail
स्रोत
यह yएक स्वर के रूप में गिना जाता है, लेकिन सवाल यह है कि यह नहीं है। ( nye cat-> ce nyat)
— लोवजो
1
@ लोजोवो वास्तव में अजीब है, क्योंकि जो कोड स्वरों की जांच करता है वह निश्चित yरूप से एक व्यंजन के रूप में व्यवहार करता है ... मैं देखता हूं कि ऐसा क्यों होता है।
— अंडरग्राउंडोरेल
17

विम, २३

/[aeiou]<cr>"xd0wndb0Pw"xP

मुझे आश्चर्य है कि अगर विम वास्तव में इस चुनौती में प्रतिस्पर्धी है। शायद गोल्फ भाषाओं के साथ नहीं, लेकिन शायद रूबी / पायथन / पर्ल / आदि के साथ।

/[aeiou]<cr>  Find the first vowel
"xd0          "Delete" (cut), to register "x, everything from here to BOL
w             Go to next word
n             Find next vowel
db            "Delete back" - delete from here to the beginning of the word
0             Go to BOL
P             Paste what we just "deleted" (cut) behind the cursor
w             Next word
"xP           Paste backwards from register "x
— Doorknob
स्रोत
11
मैं यह सम्मिलित करें मोड में है, है ना?
— एलेक्स ए।
5
@AlexA। ಠ_ಠ
— दरवाज़े
@AlexA। इन्सर्ट मोड एक अतिरिक्त कीस्ट्रोक होगा
— :)
@AlexA। मोड डालें? क्या आपका मतलब है कमांड डालना?
— ब्लैकलाइट शाइनिंग
1
@ ब्लेकलाइटिंग शाइनिंग नोप। यह एक मजाक था क्योंकि अगर आप इन्सर्ट मोड में हैं और आप उस सामान को टाइप करते हैं, तो यह किसी भी कमांड को निष्पादित नहीं करेगा; आपने इसे केवल एक फ़ाइल में टाइप किया होगा।
— एलेक्स ए।
13

पायथन, 68 63 60 बाइट्स

import re
lambda s:re.sub('([^aeiou]+|.+ )'*3,r'\3\2\1',s,1)

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

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

पैटर्न स्ट्रिंग को तीन बार दोहराया जाता है ( *3), जिसके परिणामस्वरूप पैटर्न होता है

([^aeiou]+|.+ )([^aeiou]+|.+ )([^aeiou]+|.+ )

सभी उदाहरण या तो गैर-स्वरों के गैर-रिक्त स्ट्रिंग से मेल खाएंगे, या एक एकल-रिक्त स्ट्रिंग के बाद एकल स्थान वर्ण।

पहला उदाहरण पहले शब्द की शुरुआत में व्यंजन से मेल खाएगा। चूंकि +यह लालची है, इसलिए यह संभव है कि पहले स्वर तक सभी का मिलान किया जा सके।

इस वजह से, दूसरा उदाहरण एक स्वर में शुरू होगा, इसलिए यह पहले शब्द के शेष भाग से मेल खाएगा और शब्दों को अलग करने वाले स्थान को शामिल करेगा।

पहले उदाहरण के समान, तीसरा दूसरे शब्द की शुरुआत में सभी व्यंजन मेल खाएगा, जिसके परिणामस्वरूप पूरे पैटर्न के लिए एक सफल मैच होगा।

कच्ची स्ट्रिंग \3\2\1( नियंत्रण पात्रों के साथ rअजगर को प्रतिस्थापित करने से रोकती है \3) कोष्ठक के पैटर्न के मैचों के क्रम को उलट देता है, अर्थात, यह दूसरे शब्द की शुरुआत में व्यंजन के साथ उन्हें बदल देता है , फिर पहले अक्षर से सभी अक्षर। पहले शब्द अंतरिक्ष के लिए, और अंत में पहले शब्द की शुरुआत में व्यंजन।

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

— डेनिस
स्रोत
1
बहुत कुशल रीगेक्स के साथ अजगर को रेगेक्स जादू लाने के लिए, इनाम पर बधाई। अच्छी व्याख्या भी।
— xnor
11

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

s=>s.replace(r=/\b[^aeiou ]+/g,(_,i)=>s.match(r)[+!i])

व्याख्या

s=>
  s.replace(
    r=/\b[^aeiou ]+/g,     // r = regex to match consonants
    (_,i)=>s.match(r)[+!i] // replace consonants with the consonants from the other word
  )

परीक्षा

var solution = s=>s.replace(r=/\b[^aeiou ]+/g,(_,i)=>s.match(r)[+!i])
<input type="text" id="input" value="plaster man" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
ओह, मेरा बुरा, मुझे गलत समझा गया। matchजब मैं घर पहुंचता हूं तो मैं mdn डॉक्स पर एक नज़र डालूंगा
— पैट्रिक रॉबर्ट्स
+!iचाल एक अच्छा उपाय है। +1
— ETHproductions 2
10

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

(रेगेक्स का कोई उपयोग नहीं)

यह फ़ंक्शन 2 तर्कों के माध्यम से इनपुट की अपेक्षा करता है, जैसे f('blushing','crow')। नए शब्द टपल में देता है।

S=lambda s,p="":s[0]in"aeiou"and(p,s)or S(s[1:],p+s[0])
def f(x,y):a,b=S(x);c,d=S(y);return c+b,a+d

बहुत सारे रेगेक्स समाधान हैं, इसलिए मैं कुछ ऐसा लिखना चाहता था जो पायथन की लाइब्रेरी का उपयोग नहीं करता था।

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

एकमात्र जटिल हिस्सा लंबोदर अभिव्यक्ति है S(संक्षिप्त नाम का अर्थ है " पहले स्वर से पहले एस प्लिट")। यह दिए गए शब्द के ऊपर "पुनरावृति करता है", एक अक्षर को शुरुआत के समय s(जो पूरे शब्द से शुरू होता है) के अंत तक p(जो खाली शुरू होता है) एक बार चल रहा है। पहले स्वर में इसका सामना होता है (p,s), अर्थात, (उपसर्ग, प्रत्यय)। ध्यान दें कि मापदंडों की तुलना में गलत क्रम है!

मैंने सोचा कि यह उपसर्ग के लिए लौटाए गए आदेश के लिए अधिक समझ में आता है, फिर प्रत्यय (क्योंकि आमतौर पर एक प्रत्यय प्रत्यय से पहले जाता है)। यह आदेश a,b=S(x)कोड को पढ़ने में थोड़ा आसान बना सकता है ।

लेकिन मेरे पास लंबोदर के मापदंडों में कोई विकल्प नहीं था, इसलिए मैं pपहले परिभाषित नहीं कर सकता था s। पहले पैरामीटर, s, था क्योंकि पूरे शब्द लेने के लिए pएक डिफ़ॉल्ट मान था, और डिफ़ॉल्ट पैरामीटर पिछले जाओ। ऐसा करने से, मुझे Sदो बार खाली स्ट्रिंग के साथ फ़ंक्शन को कॉल करने की आवश्यकता नहीं थी , और कुछ बाइट्स को बचाया जा सकता था। हालाँकि, शायद यह विपरीत क्रम में उपसर्ग / प्रत्यय वापस करने के लिए एक बुरा निर्णय था क्योंकि इसका उपयोग लंबोदर अभिव्यक्ति के भीतर किया गया था।

समारोह पर लंबोदर अभिव्यक्ति की पसंद के रूप में, यह कहने के लिए अधिक बाइट्स लेता def S(s,p=""):returnहै S=lambda s,p="":। मैं उस विकल्प को बना सकता हूं क्योंकि पायथन में शॉर्ट-सर्किट मूल्यांकन, और टर्नरी ऑपरेटर है। हालाँकि, मैं पर्याप्त रूप से नहीं बता सकता कि मैंने शॉर्ट-सर्किट का उपयोग कैसे किया; इसके बारे में तर्क करना कठिन है।

यह मेरा पहला उत्तर है। मुझे आशा है कि मैंने इसे सही ढंग से किया है, और एक समाधान पोस्ट करने के लिए मूल्य है जो जीत नहीं सकता है।

संपादन: धन्यवाद-टिप्पणीकार: बाइट की गिनती को थोड़ा घटाएं, दो बार, और अनावश्यक जानकारी को हटा दिया। लेखन में सुधार करने का प्रयास किया। उम्मीद है कि कोई गलती नहीं हुई।

— एन ब्रीच
स्रोत
ppcg में आपका स्वागत है, पहला पहला उत्तर :) सिर्फ फी, इस साइट के अधिकांश कार्यक्रमों में एक अनुगामी न्यूलाइन नहीं है, इसलिए आपको इसका उल्लेख करने की आवश्यकता नहीं है (दुर्लभ मामलों में जब यह आवश्यक हो, तभी लोग इसका उल्लेख करते हैं)
— अंडरग्राउंडोरेल
3
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! 1. आपको इनपुट प्रारूप के बारे में चिंता करने की आवश्यकता नहीं है। चुनौती स्पष्ट रूप से कहती है कि आप एक सूची ले सकते हैं। 2. टैग विकी में उल्लिखित चूक के अनुसार , आप गोल्फ चुनौतियों को कोड करने के लिए या तो पूर्ण कार्यक्रम या फ़ंक्शन सबमिट कर सकते हैं। इस विशेष समस्या के लिए, एक फ़ंक्शन 7 बाइट्स छोटा होना चाहिए।
— डेनिस
4
आखिरी वाक्य के बारे में, "मुझे आशा है कि [...] एक समाधान पोस्ट करने के लिए मूल्य है जो जीत नहीं सकता है।" वहाँ सबसे निश्चित रूप से है! हम सभी यहाँ मज़े करते हैं और योगदान करते हैं और एक दूसरे से सीखते हैं। मुझे यह उत्तर विशेष रूप से चतुर लगता है क्योंकि नियमित अभिव्यक्ति का उपयोग करने के लिए अधिक स्पष्ट समाधान है। बहुत अच्छा काम!
— एलेक्स ए।
एक उत्कृष्ट पहला उत्तर। यह काफी हद तक नॉन-रेगेक्स के साथ आया है। आपने शॉर्ट-सर्कुलेटिंग लॉजिकल एक्सप्रेशंस का उपयोग करने के बारे में अच्छा सोचा था, और यह पता चला कि वे अभिव्यक्ति को छोटा कर सकते हैं, हालांकि शायद आप खुद को इस बारे में सोचना चाहते हैं कि यह कैसे करना है।
— xnor
मैं वास्तव में इस तथ्य को पसंद करता हूं कि आपने एक पुनरावर्ती समाधान का उपयोग किया है। बहुत ही शान से लागू किया गया!
— ओगादे
9

सी # 6, 115 बाइट्स

string S(string a)=>System.Text.RegularExpressions.Regex.Replace(a,"([^aeiou]*)(.*) ([^aeiou]*)(.*)","$3$2 $1$4");

यह सिर्फ एक दर्द है regex के लिए नाम स्थान इतना लंबा है।

— हाथ-ए-खाना
स्रोत
2
मेरा गोश जो क्रिया है।
— कॉनर ओ'ब्रायन
4
System.Text.RegularExpressions.Regex.Replace44 अक्षर! +1 क्योंकि वह किसी प्रकार का रिकॉर्ड होना चाहिए।
— लेवल रिवर सेंट
2
... और अब आपको 44 समस्याएं हैं। ;)
— मेसन व्हीलर
9

CJam, 27 24 22 बाइट्स

2{l_{"aeiou"&}#/(N\}*o

I / O प्रति पंक्ति एक शब्द है। इसे ऑनलाइन आज़माएं!

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

2{                 }*   Do the following twice:
  l                       Read a line from STDIN.
   _                      Push a copy.
    {"aeiou"&}#           Find the index of the first character that has a non-
                          empty intersection with the string "aeiou".
               /          Split the string into chunks of that size.
                (         Shift out the first chunk, i.e., all leading consonants.
                 N\       Swap the shifted out chunk with a linefeed.
                     o  Print the topmost stack item.
— डेनिस
स्रोत
9

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

s/([^aeiou]+)(.+ )((?1))/\3\2\1/

उपरोक्त कोड 32 बाइट्स लंबा है और इसके लिए -pस्विच ( +1 बाइट ) की आवश्यकता होती है ।

प्रतिस्थापन एक @ DigitalTrauma के रेटिना उत्तर के समान है , लेकिन यह उत्तर पीसीआरई के पुनरावर्ती उपपट्टों का लाभ उठाता है ।

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

— डेनिस
स्रोत
8

जावास्क्रिप्ट ईएस 6, 93 58 52 बाइट्स

बची 6 बाइट्स ETHProductions की बदौलत!

x=>x.replace(/([^aeiou]+)(.+ )([^aeiou]+)/,"$3$2$1")

झसे आज़माओ! (केवल ES6)

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

— कोनोर ओ ब्रायन
स्रोत
मैं अपने 58 बाइट समाधान पर पोस्ट के जवाब पर क्लिक करने वाला था जब आपने यह संपादन किया था
— user81655
@ user81655 ओह, क्षमा करें कि ऐसा हुआ।
— कॉनर ओ'ब्रायन
आपको चौथे कैप्चरिंग समूह या बिल्कुल भी नहीं चाहिए $4;)
— ETHproductions
@ETHproductions ओह, हाँ! धन्यवाद!
— कॉनर ओ'ब्रायन
7

सी, 255 201 199 बाइट्स

मुझे इधर-उधर बहुत सारे सी उत्तर नहीं दिखते, इसलिए आनंद लें; इसके अलावा, पहली बार गोल्फिंग, सुझावों और समालोचना का स्वागत है।

#define S(w,p)p=strpbrk(w,"aeiou")-w
#define c ;strcpy(r
#define l c+strlen(v[1])+b+1
main(int q,char**v){char r[64],S(v[1],a),S(v[2],b)c,v[2])c+b,v[1]+a);strcat(r," ")l-a,v[1])l,v[2]+b);puts(r);}

यदि मुख्य () की आवश्यकता नहीं है, तो हम 179 बाइट्स के लिए 24 बाइट्स बचा सकते हैं

#define S(w,p)p=strpbrk(w,"aeiou")-w
#define c ;strcpy(r
#define l c+strlen(x)+b+1
s(char*x,char*y){char r[64],S(x,a),S(y,b)c,y)c+b, x+a);strcat(r," ")l-a,x)l,y+b);puts(r);}

Ungolfed:

void spoonerise(char* w1, char* w2)
{
    char rt[64];

    int p1 = strpbrk(w1, "aeiou")-w1;
    int p2 = strpbrk(w2, "aeiou")-w2;

    strcpy(rt, w2);
    strcpy(rt+p2, w1+p1);

    strcat(rt, " ");

    strcpy(rt+strlen(w1)+p2+1-p1, w1);
    strcpy(rt+strlen(w1)+p2+1, w2+p2);

    puts(rt);
}

संपादित करें: feersum के सुझाव के लिए धन्यवाद मैंने 54 बाइट्स बचाए। = D

— लिसन अससिनो
स्रोत
मैं देखने की सलाह देता हूं strpbrk।
— feersum
+1 यह एक बेहतरीन पहला जवाब है। साइट पर आपका स्वागत है।
— wizzwizz4
पुनर्मिलन के लिए धन्यवाद @ फ़ैरसम। और स्वागत करने के लिए धन्यवाद @ wizzwizz4!
— लीन
6

पायथन 2, 364 352 269 251 बाइट्स

संपादित करें: मुझे गोल्फ 83 बाइट्स की मदद करने के लिए @Cyoce का बहुत बहुत धन्यवाद!

कृपया मेरी गोल्फ में मदद करें! वैसे भी, कम से कम मैं पहला पायथन उत्तरदाता हूं। और मुझे आशा है कि मैं जावा को हरा सकता हूं, अगर कभी कोई जावा जवाब हो!

i=input()
f=l=''
A='aeiou'
for j in A:
 I=i[0];J=I.find(j)
 if ~J:
  if f:
   if f>I[0][:J]:f=I[:J];break
  else:f=I[:J]
for j in A:
 Y=i[1];J=Y.find(j)
 if ~J:
  if l:
   if l>Y[:J]:l=Y[:J];break
  else:l=Y[:J]
print I.replace(f,l,1),Y.replace(l,f,1)

इसे यहाँ आज़माएँ

— TanMath
स्रोत
5
-1 इस एकल-चरित्र चर परे गोल्फ करने की कोशिश नहीं कर के लिए
— Mego
@ मैं मैं वादा करता हूं कि मैं उस ASAP पर काम कर रहा हूं। अभी। लेकिन मैं एक रेगेक्स संस्करण पर काम कर रहा हूं।
— तन्मात्रा
@Mego कृपया संपादन देखें।
— तानमथ
5

जाप, 26 25 बाइट्स

सौभाग्य से, मैंने कुछ दिनों पहले जाप के रेगेक्स विशेषताओं में एक स्वर वर्ग जोड़ा। दुर्भाग्य से, मैंने रीगेक्स स्ट्रिंग्स में एक गैर-स्वर वर्ग या डबल बैकस्लैश के आसपास एक तरीका नहीं जोड़ा।

#¿s4 £Uf"[^\\v]+|.+
?" gX

¿कच्चे चार U + 0093 होना चाहिए। इनपुट एक बहु-पंक्ति स्ट्रिंग, एक शब्द / लाइन है। इसे ऑनलाइन आज़माएं!

संपादित करें: मैंने अब गैर-स्वर वर्ग \Vऔर एक तरह से \\(साथ %) जोड़ा है , इसलिए यह कोड अब 21 बाइट्स के लिए काम करता है : ( इसे ऑनलाइन आज़माएं )

#¿s4 £Uf"%V+|.+
?" gX

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

                     // Implicit: U = input string
#¿s4                 // Convert the char code (147) into a base-4 string "2103".
     £               // Map each char X in this string to:
      Uf"[^\\v]+|.+  //  Match each group in U of non-vowels or non-newlines,
?"                   //  with an optional trailing newline.
   gX                //  Get the item at position X in the resulting array.
                     // Implicit: output last expression

पुराना संस्करण (26 बाइट्स):

UrA="\\b[^\\v ]+"@UfA gÂ!Y

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

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

UrA="\\b[^\\v ]+"@UfA gÂ!Y  // Implicit: U = input string
  A="\\b[^\\v ]+"           // Set variable A to this regex string, which matches
                            // a word boundary followed by one or more non-vowels.
UrA              @          // Take U and replace each match X of A and its index Y with:
                  UfA       //  Take U.match(A).
                      gÂ!Y  //  Get the item at index ~~!Y (converts 0 to 1, anything else to 0).
                            // Implicit: output last expression
— ETHproductions
स्रोत
मैं चाहता हूं कि मुख्यधारा की भाषाओं में रीजैक्स के लिए एक स्वर मेटा था!
— CJ डेनिस
4

पायथन 3, 100 (या 99) बाइट्स

import re
def f(*g):a,b=[re.split("[aeiou]",r)[0] for r in g];return b+g[0][len(a):],a+g[1][len(b):]

कुछ संस्करणों के साथ खेला गया, लेकिन इसे नीचे लाने के लिए प्रतीत नहीं हो सकता है। def f(g)इसके बजाय 99 बाइट्स को नीचे ला सकते हैं ताकि यह दो अलग-अलग तारों के बजाय तारों की एक सूची ले, लेकिन मैं दो arg roue पसंद करता हूं।

विकल्प समान लंबाई है:

import re
s=re.split
def f(x,y):v="[aeiou]";a,b=s(v,x)[0],s(v,y)[0];return b+x[len(a):],a+y[len(b):]

मैंने @TanMath उपयोगों की तरह प्रतिस्थापित करने की कोशिश की, लेकिन मैं इसे किसी भी छोटे से प्राप्त नहीं कर सका। इसके अलावा, TanMath अपने जवाब को बाइट द्वारा कम कर सकता है, इसके "[aeiou]"बजाय इसका उपयोग करके "[aeiou]+"क्योंकि हमें केवल एकल उदाहरणों का मिलान करने की आवश्यकता है। अंत में, input()py2 और py3 के बीच के बदलाव को लागू करने के लिए लगता है - यह स्वचालित रूप से एक स्ट्रिंग के रूप में स्टड का मूल्यांकन करता है।

— Ogaday
स्रोत
1
शायद आप s=re.splitविकल्प में मतलब है?
— xnor
हाँ! निश्चित रूप से। यह मेरी पहली बार गोल्फिंग है, इसलिए किसी भी प्रतिक्रिया और सलाह की सराहना की जाती है।
— Ogaday
1
1. प्रश्न स्पष्ट रूप से दो तारों को एक सूची के रूप में लेने की अनुमति देता है, इसलिए लगता है कि इनका कोई अच्छा कारण नहीं *है *g। 2. दूसरा संस्करण नीचे गोल्फ हो सकता है lambda x,y,s=lambda s:re.split("[aeiou]",s)[0]:(s(y)+x[len(s(x)):],s(x)+y[len(s(y)):])।
— डेनिस
धन्यवाद @ डेनिस, जो वास्तव में काम करता है, अच्छा रीफैक्टरिंग। दिलचस्प है कि कोष्ठक की आवश्यकता होती है, और आपको एस के रूप में पास करने की आवश्यकता नहीं है दूसरे लैम्ब्डा के लिए आप क्या करते हैं? यह समाधान मुझे 98 बाइट देता है, एक प्रमुख आयात विवरण के साथ और f=।
— ओगादे
1
नहीं, sएक डिफ़ॉल्ट तर्क है, इसलिए आपको इसे निर्दिष्ट करने की आवश्यकता नहीं है। एक अनाम लैम्बडा एक स्वीकार्य सबमिशन है; f=आवश्यक नहीं।
— डेनिस
4

sed, 38 वर्ण

s/([^aeiou]+)(.+ )([^aeiou]+)/\3\2\1/

रेटिना समाधान से विस्तारित नियमित अभिव्यक्ति का उपयोग करना ।

ऊपर 37 अक्षर लंबा है और -rस्विच (+1 वर्ण) की आवश्यकता है।

उदाहरण:

$ cat input | tee /dev/tty | sed -r 's/([^aeiou]+)(.+ )([^aeiou]+)/\3\2\1/'
plaster man
blushing crow
litigating more
strong wrangler
def ghi
master plan
crushing blow
mitigating lore
wrong strangler
ghef di
— ज़ोल्ट
स्रोत
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!
— डेनिस
3

सी # 6, 165 बाइट्स

string S(string a,string b){int i=V(a),j=V(b);return b.Remove(j)+a.Substring(i)+" "+a.Remove(i)+b.Substring(j);}int V(string s)=>s.IndexOfAny("aeiou".ToCharArray());

विस्तारित:

string S(string a,string b){
    int i=V(a),
        j=V(b);
    return b.Remove(j)+a.Substring(i)+" "+a.Remove(i)+b.Substring(j);
}
int V(string s)=>s.IndexOfAny("aeiou".ToCharArray());
— हाथ-ए-खाना
स्रोत
यह बहुत पुराना है, लेकिन -2 बाइट्स के लिए "aeiou".ToCharArray()हो सकता है'a','e','i','o','u'
— अज्ञानता
नहीं, @EododimentofIgnorance, IndexOfAnyयह परम नहीं लेती है, इसलिए इसे करने की आवश्यकता होगीnew[]{'a','e','i','o','u'}
— हाथ-ई-फूड
आह, मेरी गलती, मैंने सोचा कि IndexOfAnyयह एक पारसम विधि है। वैसे भी, महान जवाब
— इग्नोरेंस
3

S, 24 चार्ट / 42 बाइट्स

ïē/⟮(⁅ᶌ]+)⟯(.+ )Ⅰ/,`⑶⑵⑴`

Try it here (Firefox only).

यदि आपको इसे समझने में मदद की जरूरत है, तो यह ES6 में बदल जाता है 

input.replace(/([^aeiou]+)(.+ )([^aeiou]+)/g,'$3$2$1')
— मामा फन रोल
स्रोत
यह किस भाषा में है? मुझे उस के लिए भी बॉक्स-कैरेक्टर मिल रहे हैं।
— जेसी विलियम्स
यह @JesseWilliams कहा जाता है ESMin ।
— ETHproductions
यह अच्छा होगा यदि इंटरपेटर के पास जाप की तरह कुछ है जहाँ यह आपको दिखाता है कि जेएस
— जेनेरिक यूजर
कोड चलाने पर संकलित JS JS कंसोल में लॉग इन किया जाता है।
— मामा फन रोल
3

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

"$args "-replace('(.*?)([aeiou]\S+) '*2),'$3$2 $1$4'

e.g. 
PS C:\scripts\> .\Spoonerise.ps1 'blushing crow'
crushing blow

यह चार कैद समूहों के साथ एक रेगीक्स की जगह है; साथ में:

  • स्ट्रिंग गुणन का विस्तार करने के लिए:
    • ('(.*?)([aeiou]\S+) '*2) सेवा '(.*?)([aeiou]\S+) (.*?)([aeiou]\S+) '
  • "$args "इसलिए regex में अनुगामी अंतरिक्ष इसे तोड़ने नहीं होगा एक स्ट्रिंग में बलों आर्ग सरणी, और पीछे अंतरिक्ष कहते हैं।
— TessellatingHeckler
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 120 107 102 101 99 92 बाइट्स

  • धन्यवाद downgoat!

यदि पैरामीटर इस तरह एक वस्तु थे, और पिछड़े:
var a = {x: "man", y:"plaster"]}

a.b=(e=>e.slice(e.search`[aeiou]`));with(a){c=b(x),d=b(y),x=x.replace(c,d);y=y.replace(d,c)}
— मोड़ना
स्रोत
.match(/[aeiou]/).indexबन सकता है:.search`[aeiou]`
— डाउनगेट
3

पायथन, 129 108 105 109 बाइट्स

यह कार्यक्रम इस तरह शब्दों की एक सूची में ले जाता है ["master","plan"]

संपादित करें : धन्यवाद @Volatility

संपादित करें: अब re.split का उपयोग कर

import re
a=re.split
c='[aeiou]+'
i,j=input()
f=a(c,i)[0]
l=a(c,j)[0]
print i.replace(f,l,1),j.replace(l,f,1)

यह उत्तर रेगेक्स का उपयोग करता है जैसा कि उनमें से अधिकांश करते हैं।

इसे यहाँ आज़माएँ

— TanMath
स्रोत
ध्यान दें कि एक str.replaceप्रतिस्थापन के सभी उदाहरणों को प्रतिस्थापित करता है , इसलिए आप इसे एक प्रतिस्थापन में सीमित करना चाहते हैं .replace(f,l,1)। हालाँकि, आप एक गुच्छा को उपयोग करके i,j=input()और रिबंडिंग re.findallऔर '[^aeiou]+'सिंगल कैरेक्टर वेरिएबल्स में सेव कर सकते हैं ।
— अस्थिरता
यह काम नहीं करता है जैसा कि यह है; यहां तक ​​कि दो एक-अक्षर शब्द आपको तीन वर्ण देंगे, और आप input()दो चर में अनपैक करने का प्रयास कर रहे हैं । क्या आपका मतलब था i,j=input().split()(और raw_input()पायथन 2 में)?
— ब्लैकलाइट शाइनिंग
1
@Blacklight शब्द को कम से कम एक स्वर और एक व्यंजन की आवश्यकता है। इनपुट स्ट्रिंग्स की एक सूची में ले जाता है इसलिए मैं पहला शब्द हूं और j दूसरा है।
— तनमठ
@ टैनमैथ जहां तक ​​मुझे पता है कि डिफ़ॉल्ट रूप से इसकी अनुमति है, लेकिन आपको शायद जवाब में कहना चाहिए कि इसकी आवश्यकता है
— भूमिगत
यह बहुत अधिक प्रतिस्थापित करता है। "sass","bit" -> "babb", "sit"।
— xnor
3

जावा 8, 343 बाइट्स

यहां आपके पास आपका पहला जावा-उत्तर है। गोल्फ के साथ अनुभव नहीं है, इसलिए हर सुझाव की सराहना की है!

java.util.function.Function;public class C{public static void main(String[] a){Function<String, Integer>f=s->{for(int i=0;i<s.length();++i)if("aeiou".contains(s.substring(i,i+1)))return i;return 0;};int i1=f.apply(a[0]),i2=f.apply(a[1]);System.out.println(a[1].substring(0,i2)+a[0].substring(i1)+" "+a[0].substring(0,i1)+a[1].substring(i2));}}

Ungolfed:

public class SpooneriseWords {
    public static void main(String[] args)
    {       
        Function<String, Integer> f = s -> {
            for(int i = 0; i < s.length(); ++i)
                if("aeiou".contains(s.substring(i, i + 1))) 
                    return i;
            return 0;
        };

        int i1 = f.apply(args[0]);
        int i2 = f.apply(args[1]);
        System.out.println(args[1].substring(0, i2) + args[0].substring(i1));
        System.out.println(args[0].substring(0, i1) + args[1].substring(i2));
    }
}
— Denker
स्रोत
क्या है java.util.function.Function? मुझे अत्यधिक संदेह है कि यह तब तक होना चाहिए, जब तक आपका मतलब न हो import, लेकिन आयात को छोड़ दें क्योंकि आप केवल एक बार इसका उल्लेख करते हैं। बदले public class C{public static void Main(String[] a)के लिएinterface C{void Main(String[]a)
— बिल्ली
Function<String, Integer>व्हॉट्सएप की जरूरत नहीं है
— बिल्ली
से पाश के लिए बदलने for(int i=0;i<s.length();++i)if("aeiou".contains(s.substring(i,i+1)))return i;के लिएfor(int i=0;i++<s.length();if("aeiou".contains(s.substring(i,i+1))){return i;})
— बिल्ली
i1एक भयानक, बहुत लंबा varname है।
— बिल्ली
यही कारण है, बदल जाता है Function<String, Integer>करने के लिए java.util.function.Function<String,Integer>और ड्रॉप आयात
— बिल्ली
3

ऑक्टेव, 96 बाइट्स

ऑक्टेव के इनलाइन असाइनमेंट और 'इंडेक्स-एनीवेयर' फंक्शनलिटी की बदौलत, यह पूरी बात सिर्फ एक एकल, अनाम फ़ंक्शन की परिभाषा है। असल में, हम spoonerized स्ट्रिंग को फिर से संगठित में कट ऑफ अंक संगृहीत करने के दौरान aऔर b। मैं इनलाइन fफ़ंक्शन से विशेष रूप से खुश हूं , जो कट-ऑफ़ पॉइंट को पाता है, और मुझे find(ismember(a,b),1)दो बार पूरी ' ' चीज़ का उपयोग करने से रोकता है । इसके अलावा, कोई रेगेक्स :) ।

@(p,q)[q(1:(a=(f=@(m)find(ismember(m,'aeoui'),1))(q))-1),p(b=f(q):end),32,p(1:b-1),q(a:end)];
— Sanchises
स्रोत
2

टीस्क्रिप्ट , 27 बाइट्स

xg/(\w+)(.+ )(\w+)/,"$3$2$1

\wवास्तव में है [^aeiou]।

— Downgoat
स्रोत
रुको, आपने डिफ़ॉल्ट \wरेगेक्स मेटा को बदल दिया है [^aeiou]? क्यों?
— ETHproductions
@ETHproductions जब मैं कस्टम चार कक्षाएं बना रहा था। मैं भूल गया कि \wजावास्क्रिप्ट द्वारा पहले से ही इस्तेमाल किया गया था। मैं इसे जल्द ही बदल
— दूंगा
2

अमृत ,143 117 बाइट्स

s=fn w->String.split_at(w,elem(hd(Regex.run(~r/[aeiou]/,w,return: :index)),0))end
{v,w}=s.(a)
{x,y}=s.(b)
[x<>w,v<>y]

पहले स्वर पर दो तारों (ए, बी) को विभाजित करें और वापस लौटने के लिए नए तारों का निर्माण करें।

संपादित करें: टुपल्स elemसे मूल्यों को प्राप्त करने के लिए क्लंकी कॉल के बजाय पैटर्न मिलान का उपयोग करके कुछ बाइट्स प्राप्त करें।

— srecnig
स्रोत
2

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

मैं मान रहा हूं कि सिर्फ एक फंक्शन भी ठीक है।

String s(String[]i){String r="[aeiou]",f=i[0].split(r)[0],s=i[1].split(r)[0];return s+i[0].substring(f.length())+" "+f+i[1].substring(s.length());}

split(regex)दुर्भाग्य से सीमांकक खपत करता है, जिसका अर्थ है कि मुझे substringप्रत्यय प्राप्त करने के लिए उपयोग करना होगा।

— ईसीएस
स्रोत
2

पायथ, 30 28 बाइट्स

इनपुट लेता है और दो शब्दों की सूची के रूप में आउटपुट देता है।

ACm,Kh:d"[aeiou]"3.-dKQ+V_GH

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

— ल्यूक
स्रोत
मुझे लगता है कि आप ढूंढ रहे हैं ACm,Kh:d"[aeiou]"3.-dKQ+V_GH। AG और H को दो-तत्व सूची प्रदान करता है, और Cस्थानांतरित करता है। कुछ बेहतर भी हो सकता है।
— lirtosiast
2

पायथन (कोई रेगेक्स), 85 बाइट्स

t=lambda s:s[1]in'aeiou'or-~t(s[1:])
lambda a,b:(b[:t(b)]+a[t(a):],a[:t(a)]+b[t(b):])

नमूना रन:

>>> t=lambda s:s[1]in'aeiou'or-~t(s[1:])
>>> lambda a,b:(b[:t(b)]+a[t(a):],a[:t(a)]+b[t(b):])
<function <lambda> at 0x7f495e534398>
>>> _('plaster', 'man')
('master', 'plan')

tएक पुनरावर्ती कार्य है जो अपने तर्क में पहले चरित्र के बाद सबसे पहले स्वर के सूचकांक की गणना करता है s। यदि दूसरा वर्ण s[1]एक स्वर है, तो यह मूल्यांकन करता है True, जिसका intमूल्य है 1। अन्यथा यह हटाए गए पहले चरित्र के साथ एक पुनरावर्ती कॉल करता है, और उपयोग किए गए सूचकांक में 1 जोड़ता है -~(दो के पूरक के पूरक) का उपयोग करके । अंत में, tस्पूनरवाद की गणना करने के लिए स्ट्रिंग स्लाइसिंग के लिए सूचकांकों के रूप में उपयोग किया जाता है।

— एंडर्स कसीगोर
स्रोत
1

GNU Awk 4.0, 48 वर्ण

split($0,a,/\<[^aeiou]+/,s)&&$0=s[2]a[2]s[1]a[3]

नमूना रन:

bash-4.3$ for s in 'plaster man' 'blushing crow' 'litigating more' 'strong wrangler' 'def ghi'; do
>     echo -n "$s -> "
>     awk 'split($0,a,/\<[^aeiou]+/,s)&&$0=s[2]a[2]s[1]a[3]' <<< "$s"
> done
plaster man -> master plan
blushing crow -> crushing blow
litigating more -> mitigating lore
strong wrangler -> wrong strangler
def ghi -> ghef di
— आदमी काम पर है
स्रोत
1

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

"$args"-replace'([^aeiou]+)(.*)\s([^aeiou]+)(.*)','$3$2 $1$4'

प्रत्येक शब्द के पहले गैर-स्वर वर्णों को स्वैप करने के लिए रेगेक्स का उपयोग करता है

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