42

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

इनपुट: a test case।
यहाँ व्यंजन हैं t,s,t,c,s। उन्हें उल्टे क्रम में आना चाहिए, यानी s,c,t,s,tवापस स्ट्रिंग में उसी स्थिति में डाला जाना चाहिए जहां पूर्व-उलट अक्षर स्थित थे a sect sate:।
इनपुट: well-done। आउटपुट: nedl-lowe।
इनपुट: reverse the consonants। आउटपुट: setenne sne cohtosarvr।

यह कोड गोल्फ है, सबसे छोटा समाधान जीतता है।

Y इसे स्वर की परवाह किए बिना माना जाना चाहिए और यह उलटा नहीं है।

कुछ भी, साथ ही संख्या, विराम चिह्न, उद्धरण और अन्य प्रतीक ( @#$%^&*(){}[]\|/<>~-_+=`), इनपुट में संभावित रूप से प्रकट हो सकते हैं।

code-golf string

— nicael
स्रोत

16

रेटिना, 22 21 20 17

O#^`[b-z-[eiouy]]

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

1 बाइट लेके नन को धन्यवाद!

मार्टिन को 4 बाइट्स धन्यवाद!

Oका अर्थ है सॉर्ट, और #संख्यात्मक मान द्वारा सॉर्ट करने का मतलब है। चूंकि मिलान किए गए वर्णों में से कोई भी कभी भी संख्यात्मक मान नहीं होगा, सभी अक्षरों का वजन समान है: 0. ^सॉर्ट किए गए मानों के क्रम को उल्टा करने का मतलब है, जो स्थिर सॉर्टिंग के लिए धन्यवाद का अर्थ है कि मान उलट गए हैं।

-[...]बाहरी चरित्र वर्ग और इस आंतरिक वर्ग के बीच समुच्चय अंतर करने का साधन। यह .NET का हिस्सा है और आप MSDN पर अधिक पढ़ सकते हैं ।

— FryAmTheEggman
स्रोत

बहुत अच्छा। है -[...]रेटिना के लिए विशिष्ट, या .net regexes के लिए विशिष्ट या यह एक सामान्य regex विशेषता यह है कि मैं अब तक अनदेखी की है?

— डिजिटल ट्रामा

@DigitalTrauma इस सिंटैक्स के साथ मुझे लगता है कि यह .NET के लिए विशिष्ट है। अन्य स्वादों में वर्ण वर्ग के प्रतिच्छेदन भी होते हैं, लेकिन फिर मुझे लगता है कि वाक्यविन्यास आमतौर पर है [...&&[^...]]।

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

@MartinEnder मुझे इन्हें sed और grep के साथ आज़माना होगा। पूरी तरह से sed में यह है, लेकिन शायद PCRE- मोड grep।

— डिजिटल ट्रामा

1

पर्ल 6 का उपयोग करता है <[b..z] - [eiouy]>या <:Ll - [aeiouy]>अंतर सेट करने के लिए करता है

— ब्रैड गिलबर्ट b2gills

15

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

s='';c=()
for x in input():b='{'>x not in'aeiouy'<x;s+=b*'%s'or x;c=(x,)*b+c
print s%c

उद्धरणों में एक स्ट्रिंग के रूप में इनपुट लेता है। इनपुट के माध्यम से दोहराता, के साथ प्रत्येक व्यंजन की जगह %sमें s। ट्यूपल cउल्टे क्रम में सामना किए गए व्यंजन को संग्रहीत करता है। फिर, स्ट्रिंग की जगह स्वरूपण %sमें की sमें व्यंजन के साथ c।

व्यंजन जांच के लिए Sp3000 के लिए धन्यवाद, जिसने व्यंजन को सूचीबद्ध करने पर 4 बाइट बचाए।

— XNOR
स्रोत

1

यह कोड गोल्फ का एक सुंदर सा है :)

— लिन

वास्तव में सुरुचिपूर्ण, और आश्चर्यजनक रूप से छोटा, यह पायथन है

— DevilApple227

9

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

Øaḟ“<1Ṛż»
e€¢œpżf¢Ṛ$

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

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

Øaḟ“<1Ṛż»   Helper link. No arguments.

Øa          Yield the lowercase alphabet/
   “<1Ṛż»   Decompress that string, yielding "oui aye".
  ḟ         Filter; remove the characters from the right string from the left one.


e€¢œpżf¢Ṛ$  Main link. Argument: s (string)

  ¢         Call the helper link, yielding the string of all consonants.
e€          Test each character of s for membership.
   œp       Partition s at members/consonants.
         $  Combine the three links to the left into a monadic chain.
      f¢    Filter by presence in the consonant string.
        Ṛ   Reverse the result.
     ż      Zipwith; interleave chunks of non-consonants and reversed consonants.

— डेनिस
स्रोत

6

जावास्क्रिप्ट ईएस 6, 82 81 80 78 बाइट्स

मार्टिन और लीकी नून और नील को 2 बाइट्स में से प्रत्येक के लिए एक बाइट धन्यवाद!

a=>a.replace(r=/(?[_aeiouy])\w/g,e=>[...a].reverse().join``.match(r)[i++],i=0)

परिक्षण

f=
a=>a.replace(r=/(?![aeiouy])[a-z]/g,e=>[...a].reverse().join``.match(r)[i++],i=0)
;
q.onchange=q.onkeydown=q.onkeyup=function(){
  o.innerHTML = "";
  o.appendChild(document.createTextNode(f(q.value)));
}

*{font-family:Consolas,monospace;}

<input autocomplete="off" id=q>
<div id=o></div>

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

— कोनोर ओ ब्रायन
स्रोत

1

यह फ़ंक्शन तर्कों का सबसे बुरा दुरुपयोग है।

— लीक नून

/(?![aeiouy])[a-z]/g

— लीक नून

चाहेंगे /(?[_aeiouy])\w/gकाम करते हैं?

— नील

@ नील नं। _, जो कि एक प्रतीक है, जिसे ओपी जगह पर रखना चाहता है।

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

1

अपने डेमो में, आप q.onchange=q.onkeydown=q.onkeyup=सिर्फ q.oninput=...

— पैट्रिक रॉबर्ट्स

5

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

s=input()
b=[x for x in s if x in'bcdfghjklmnpqrstvwxz']*2
print''.join(x in b and b.pop()or x for x in s)

इनपुट की अपेक्षा करता है "quotes", जिसमें मुझे लगता है कि अनुमति है।

— लिन
स्रोत

4

पाइके, 18 बाइट्स

FD~c{IK_#~c{)oR@(s

यहाँ यह कोशिश करो!

या नए संस्करण के साथ 16 बाइट्स:

(यदि सभी स्ट्रिंग आउटपुट रिटर्न के लिए बदलें और स्ट्रिंग इनपुट था, तो सूची के बजाय स्ट्रिंग लौटाएं)

FD~c{IK_#~c{)oR@

यहाँ यह कोशिश करो!

~c इसमें व्यंजन शामिल हैं: bcdfghjklmnpqrstvwxz

F                - For i in input:
  ~c{I           -  if i in "bcdfghjklmnpqrstvwxz":
       _#~c{)    -    filter(reversed(input), <-- in "bcdfghjklmnpqrstvwxz")
             oR@ -   ^[o++]

— नीला
स्रोत

4

GNU सेड, 73

स्कोर में शामिल है -rफ्लैग फॉर सेड के लिए +1 ।

:
s/([b-df-hj-np-tv-xz])(.*)([b-df-hj-np-tv-xz])/\u\3\2\u\1/
t
s/./\l&/g

Ideone।

बार-बार पहले और आखिरी निचले हिस्से के व्यंजन को स्विच करता है और उन्हें ऊपरी मामले में परिवर्तित करता है, जब तक कि अधिक मैच न हों। फिर पूरे स्ट्रिंग को लोअरकेस में बदलें।

— डिजिटल आघात
स्रोत

4

जे, 53 बाइट्स

C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'bcdfghjklmnpqrstvwxz'

शायद सबसे अच्छा तरीका नहीं है, लेकिन मैं उपयोग करना चाहता था C.क्योंकि यह क्रमपरिवर्तन का उपयोग करके हल किया जा सकता है।

प्रयोग

   f =: C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'bcdfghjklmnpqrstvwxz'
   f 'a test case'
a sect sate
   f 'well-done'
nedl-lowe
   f 'reverse the consonants'
setenne sne cohtosarvr

व्याख्या

C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'...'  Input: s
                               '...'  The list of consonants
                            e.&'...'  Generate a boolean mask where an index is true
                                      if the char at that index in s is a consonant
                         I.@          Get a list of the true indices
                  (  |.)@             Reverse that list
                  (,.  )@             Join the original and reversed list as columns
            /:~"1@                    Sort each row of that 2d list
         ~.@                          Take the distinct values in each row
       <@                             Box them
   [:~.                               Take the distinct boxes - Now represents the
                                      permutation needed to solve this in cycle notation
C.~                                   Permute s according the cycles and return

— मील की दूरी पर
स्रोत

4

MATL, 18 22 21 बाइट्स

tt2Y211Y2'y'hX-m)P5M(

1 बाईट ने @Luis को धन्यवाद दिया

दुर्भाग्य से इसमें से सबसे लंबे हिस्से को व्यंजन ( 2Y211Y2'y'hX-) की सूची मिल रही है ।

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

व्याख्या

            % Implicitly grab the input
tt          % Duplicate twice
2Y2         % Grab the pre-defined list of all lower-case letters
llY2        % Grab the pre-defined list of lower-case vowels (excluding 'y')
'y'h        % Add 'y' to the list of vowels
X-          % Find the set difference between these two lists (the consonants)
m           % Create a boolean array the size of the input that is true for all consonants
)           % Use this as an index to grab all consonants
P           % Reverse the order of the consonants
5M          % Get the boolean array again
(           % Re-assign the flipped consonants with the original consonant locations
            % Implicitly dislpay the result

— Suever
स्रोत

1 बाइट कम:tt2Y211Y2'y'hX-m)P5M(

— लुइस मेंडो

@LuisMendo उत्कृष्ट विचार, धन्यवाद!

— स्वेअर

4

पर्ल 5 (58 + 4 = 62 बाइट्स)

$_=<>;$r=qr/(?![eiouy])[b-z]/;@a=/$r/g;s/$r/pop@a/ge;print

-0777झंडे के साथ चलने के लिए +4 जुर्माना , जो पर्ल को स्लैप मोड में सेट करता है ताकि नए सिरे को सही ढंग से संभाल सके।

STDIN के माध्यम से इनपुट को स्वीकार करता है और STDOUT को प्रिंट करता है।

व्याख्या

                   $_=<>;   Read the input
 $r=qr/(?![eiouy])[b-z]/;   Save the regex; we'll be using it twice
                @a=/$r/g;   Store all the consonants in an array
           s/$r/pop@a/ge;   Replace each consonant with the final value in the array and pop
                   print    Output the result

— सिल्वियो मायोलो
स्रोत

4

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

s=>s.split(/([^\W\d_aeiouy])/).map((c,i,a)=>i&1?a[a.length+~i]:c).join``

/([^\W\d_aeiouy])/सरणी में विषम संख्या वाली प्रविष्टियों में गिरने वाले व्यंजन में परिणाम पर विभाजन । यह तब उन प्रविष्टियों को स्विच करने के लिए पर्याप्त होता है, जो समतुल्य प्रविष्टि के साथ सरणी के अंत से वापस आ जाती हैं और परिणाम को एक साथ जोड़ देती हैं।

— नील
स्रोत

अच्छी नौकरी! मैंने बंटवारे के बारे में नहीं सोचा था।

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

5

लगता है कि CIA ने आपके कोड में घुसपैठ कर ली है।

— पैट्रिक रॉबर्ट्स

मैंने उसी

— रेक्सपैप

4

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

अद्भुत 20% की बचत thx @Neil संपादित करें

पार्टी के लिए देर से, लेकिन ऐसा लगता है कि सभी जावास्क्रिप्ट लोगों को कुछ याद किया

a=>a.replace(r=/[^\W\d_aeiouy]/g,_=>c.pop(),c=a.match(r))

परीक्षा

f=a=>a.replace(r=/[^\W\d_aeiouy]/g,_=>c.pop(),c=a.match(r))

function test() {
  var i=I.value
  O.textContent=f(i)
}

test()

#I { width:90% }

<input id=I oninput="test()" value="reverse the consonants."><pre id=O></pre>

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

— edc65
स्रोत

@nicael यह बस जगह से बाहर है (नाइटपिक!) (लेकिन ध्यान देने के लिए धन्यवाद)

— edc65

जैसे कि यह बहुत बुरा नहीं था कि (मेरे समाधान में त्रुटि के कारण) आप मुझे पहले से ही मार रहे हैं, ऐसा लगता है कि आपको 13 बाइट्स का उपयोग करके बचाने में सक्षम होना चाहिए c.pop()।

— नील

@ नील वाह धन्यवाद, यह बहुत बड़ा सुधार है

— edc65

4

पर्ल 5, 92 68 55 बाइट्स

सहेजे गए 37 बाइट्स @manatwork की मदद के लिए धन्यवाद । ;-)

$_=<>;@b=@a=/[^\Waeiou]/g;print$_~~@b?pop@a:$_ for/./g

पर्ल का पायथन समाधान @Lynn का अनुवाद ।

— मेष राशि
स्रोत

नमस्कार, और PPCG में आपका स्वागत है!

— NoOneIsHere

1

@NoOneIsHere क्षमा करें, PPCG क्या है।

— मेष राशि

पी rogramming पी uzzles और सी स्तोत्र जी OLF।

— NoOneIsHere

1

कुछ " g" बल वहाँ मदद करेगा: @s=split//;→ @s=/./g;और for(@s){push@a,$_ if(/[^\Waeiou]/);}→ @a=/[^\Waeiou]/g;। मेरा मतलब है, m//साथ gसंशोधक रिटर्न सभी मैचों की एक सरणी।

— मैनटवर्क

1

असाइनमेंट में शामिल होने से 2 वें संस्करण को कम किया जा सकता है @b=@a=…:। इसके अलावा forब्लॉक में एक भी बयान (जिस स्थिति में ;इसके बाद आवश्यक नहीं है), आप इसे बयान संशोधक में बदल सकते हैं और सीमांकक को छोड़ सकते हैं print$_~~@b?pop@a:$_ for/./g:। (येप, सॉरी, चूक गए: @sकिसी वैरिएबल में वैल्यू स्टोर करने की जरूरत नहीं है ।)

— मैनटवर्क

3

पायथ, 26 25 24 23 बाइट्स

सी: क्यू ++ \ [जेजी "aeiouy" \] 3_ @ जम्मू
JG "aeiouy" sm! @DJ @ _ @ JQ ~ hZ <- सिर्फ @ _ @ की वजह से इसे बनाए रखना
जेजी "aeiouy" SM? @ डीजे @@ JQ = TZ
एसएम? @ डीजे-जी "aeiouy" @@ JQ = TZ
एसएम | -dJ-जी "aeiouy" @@ JQ = TZ

परीक्षण सूट।

— लीक नन
स्रोत

3

जूलिया, 53 बाइट्स

!s=s[flipud(i)]=s[i=find(c->'}'>c∉"aeiouy"<"$c",s)]

यह एक वर्ण सरणी को इनपुट के रूप में लेता है और इसके व्यंजन को जगह में उलट देता है। इसे ऑनलाइन आज़माएं!

लोअरकेस व्यंजन जांच के लिए क्रेडिट @ Sp3000 पर जाता है।

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

i=find(...,s)s के सभी सूचकांकों की पैदावार करता है , जिसके लिए विधेय ... सच लौटाता है और उन्हें इसे बचाता है चर i ।

c->'}'>c∉"aeiouy"<"$c"तीन परीक्षण करता है और यदि सभी सकारात्मक हैं तो ही सही ।

'}'>cजाँच करता है कि चरित्र c { से पहले आता है ।
"aeiou"जाँचता है कि क्या स्ट्रिंग c एक के बाद आता है ।
c∉"aeiouy"पुष्टि करता है कि c एक स्वर नहीं है।

अंत में, s[i]सभी व्यंजन और पैदावार s[flipud(i)]=s[i]में उन्हें नियुक्त पदों के लिए रों कि में में उलट सूचकांक के अनुरूप मैं ।

— डेनिस
स्रोत

यह किस एन्कोडिंग का उपयोग करता है ( ∉)?

— अदाम

1

यूटीएफ -8, दुर्भाग्य से।

— डेनिस

3

जावा, 319 305 261 188 बाइट्स

इस के साथ मदद करने के लिए @ लीक नून को श्रेय :-)

char[]r(char[]s){int i=0,j=0,n=s.length;char[]o=new char[n];for(;i<n;i++){if((s[i]+"").matches("(?![eiouy])[b-z]")){o[j++]=s[i];s[i]=65;}}for(i=0;i<n;i++)if(s[i]==65)s[i]=o[--j];return s;}

पुराना:

s(String p){int i=0,j=0;char[]s=p.toCharArray(),o=p.toCharArray();for(;i<s.length;i++){if(((s[i]+"").matches("[aeiouy @#$%^&*(){}\\[\\]\\|/\\\\<>~\\-_+=`]")))continue;o[j++]=(s[i]);s[i]='A';}for(i=0;i<s.length;i++)if(s[i]=='A')s[i]=o[--j];return new String(s);}

यहां से ली गई प्रेरणा ❤

Ungolfed

String s(String p){
    int i = 0, j = 0;
    char[]s=p.toCharArray(),o=p.toCharArray();
    for (;i<s.length;i++) {
        if (((s[i]+"").matches("[aeiouy @#$%^&*(){}\\[\\]\\|/\\\\<>~\\-_+=`]"))) continue;
        o[j++] = (s[i]); // Store the consonant into o
        s[i] = 'A'; // Put a special character in its place
    }
    for (i=0;i<s.length;i++)
        if (s[i] == 'A') // If special character
            s[i] = o[--j]; // Put back the consonant in reverse order
    return new String(s);
}

— पागल
स्रोत

2

आप 0विशेष चरित्र के रूप में उपयोग कर सकते हैं ( nullस्ट्रिंग में नहीं होने की गारंटी है), और आप इसे चेक कर सकते हैं s[i]<1(कोई नकारात्मक चार नहीं है)

— लीक नून

मैं तुझे charचोदूंगा :)

— gcampbell

3

रूबी, 53 50 बाइट्स

-मानटवर्क से -3 बाइट्स

->s{i=0;s.gsub(r=/[^\Waeiouy_]/){s.scan(r)[i-=1]}}

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

— मूल्य स्याही
स्रोत

कोड को अप्रयुक्त पैरामीटर क्यों ब्लॉक किया गया है?

— मैनटवर्क

1

@manatwork सही है। रूबी आपको अप्रयुक्त पैरामीटर को छोड़ने की अनुमति देगा क्योंकि यह एक ब्लॉक है। आप वहां तीन पात्रों को शेव कर सकते हैं।

— सिल्वियो मेयोलो

@manatwork, मैं शुरू में इसे किसी चीज़ के लिए इस्तेमाल करने जा रहा था, लेकिन तब मैं नहीं था और परिणामस्वरूप इसे हटाने के लिए भूल गया

— मान स्याही

2

पायथन 2, 103 98 100 बाइट्स

import re
def r(s):a=re.split("([^\W\d_aeiouy])",s);print''.join(sum(zip(a[::2],a[-2::-2]+['']),()))

मेरे जावास्क्रिप्ट उत्तर का पोर्ट। संपादित करें: @ डेनिस of के लिए 5 बाइट्स सहेजे गए, जिनमें से मुझे तुरंत दो फिक्सिंग अंक खर्च करने थे।

— नील
स्रोत

2

आर, 120 बाइट्स

नया उत्तर:

az=function(x){
y=strsplit(x, NULL)[[1]]
a=regexpr("[bc-df-hj-np-tv-z]", y)
y[a==1]=rev(y[a==1])
paste(y, collapse="")
}

x के रूप में एक वर्ण स्ट्रिंग लेता है

az("reverse the consonants")
[1] "setenne sne cohtosarvr"

नीचे पुरानी प्रतिक्रिया (110 बाइट्स) मेरी ओर से खराब रूप थी, जिसने बस व्यंजन को उलट दिया:

xrev=function(x){y=rev(strsplit(x, NULL)[[1]])
paste(y[is.na(match(y, c("a", "e","i","o","u","y")))], collapse="")}

— टिम
स्रोत

विराम चिह्न क्यों उलटा है? और स्वर कहाँ गए?

— निकेल

93 बाइट्स tio.run/##PYxBDoIwEEX3PUXTjZ2EEg8gXkRZ1DKIppmSzqig8exYEnX3/...

— Sumner18

2

एपीएलएक्स, 31 बाइट्स

(c/t)←⌽t/⍨c←(t←⍞)∊⎕a~'aeoiuy'
t

⎕a~'aeoiuy'कम वर्णमाला के बिना स्वर
t←⍞स्टोर चरित्र इनपुट टी
c←( ... )∊स्टोर बुलियन "व्यंजन?" टी रिवर्स से सी
t/⍨ एक्सट्रैक्ट (व्यंजन) के रूप में ( उल्टे वाले) बदले हुए स्ट्रिंग को वापस लौटाते हैं
⌽
(c/t)←
t

— एडम
स्रोत

1

पायथन 2.7, 144 बाइट्स

def f(a):c='bcdfghjklmnpqrstvwxz';b=[x for x in list(a[::-1])if x in c];[b.insert(x,a[x])for x in range(len(a))if a[x]not in c];return''.join(b)

यह पहले व्यंजन की एक उलट सूची बनाता है, फिर प्रत्येक अन्य पात्रों को उनके मूल सूचकांक में वापस सम्मिलित करता है।

संयुक्त राष्ट्र के golfed:

s = 'well-done'
reverse = list(s[::-1])
consonants = [i for i in reverse if i in 'bcdfghjklmnpqrstvwxz']

for x in range(len(s)):
    if s[x] not in 'bcdfghjklmnpqrstvwxz':
        consonants.insert(x,s[x])

print(''.join(consonants))

https://repl.it/C30O

— atlasologist
स्रोत

आप बाइट्स को 'bcdfghjklmnpqrstvwxz' के लिए एक वैरिएबल बनाकर और उस वेरिएबल को कॉल करके बचा सकते हैं

— MCMastery

1

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

Module[{h,v,i},v=Characters["aeiouy "];h[s_]:=SortBy[Flatten[Thread/@Transpose@{v,#[[All,1]]&/@(StringPosition[s,#]&/@v)},1],Last];i[s_,{a_,n_}]:=StringInsert[s,a,n];Fold[i,StringReverse@StringReplace[#,v->""],h@#]]&

— मार्टिन
स्रोत

1

हास्केल, 157 131 बाइट्स

k="bcdfghjklmnpqrstvwxz";f c((r:q),s)=if c`elem`k then(q,r:s)else(r:q,c:s);f c("",s)=("",c:s);g s=snd$foldr f(filter(`elem`k)s,"")s

अपडेट करें

@ एटलसॉजोलॉजिस्ट के समाधान ने मुझे एहसास दिलाया कि मुझे केवल जोड़े के बजाय व्यंजन की एक सूची की आवश्यकता है (क्योंकि उन्हें सही गुना का उपयोग करने की आवश्यकता नहीं है।)

Ungolfed

consonants = "bcdfghjklmnpqrstvwxz"

-- Combining function (right fold, improved)
f :: Char -> (String, String) -> (String, String)
f c ((r:rest), s) = if c `elem` consonants then (rest, r:s) else (r:rest, c:s)
f c ("", s) = ("", c:s)

transform :: String -> String
transform s = snd $ foldr f (filter (`elem` consonants) s, "") s


main = do
    line <- getLine
    putStrLn . transform $ line

पुराना

c="bcdfghjklmnpqrstvwxz";n c(a@((f,t):q),s)=if c==f then(q,t:s)else(a,c:s);n c([],s)=([],c:s);g s=let z=filter(`elem`c)s in snd$foldr n(zip (reverse z)z,"")s

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

थोड़ा आदिम, लेकिन मैं पहले उत्तरों को देखे बिना यह पता लगाना चाहता था। :)

— sudee
स्रोत

4

कुछ सुझाव: ए) के बजाय गार्ड का उपयोग करें if ... then ... else। b) fइन्फिक्स ऑपरेटर के रूप में बेहतर लिखा गया है, कहते हैं %। सी) की आंतरिक जोड़ी की कोई आवश्यकता नहीं ()है ((r:q),s)। घ) की जगह ""के साथ _के 2 लाइन में f। सभी सभी ( kएक ही रहता है) c%(r:q,s)|c`elem`k=(q,r:s)|1<2=(r:q,c:s);c%(_,s)=("",c:s);g s=snd$foldr(%)(filter(`elem`k)s,"")s:।

— ०२:२६

1

एस-लैंग ,17 16 बाइट्स (गैर-प्रतिस्पर्धात्मक)

एक बाइट को सहेजा क्योंकि s-lang को अब अंतिम तर्क ब्रैकेट की आवश्यकता नहीं है

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

r[(?![aeiouy])\w

मैंने एक स्ट्रिंग हेरफेर गोल्फिंग भाषा पर काम करना शुरू कर दिया (मैं अब एक समय के लिए ऐसा करना चाहता हूं), और मुझे लगा कि इस पर काम करना एक मजेदार सवाल होगा।

स्पष्टीकरण:

rकिसी दिए गए rexx वर्ण मिलान के साथ स्ट्रिंग को उलट देता है (यदि कोई regex तर्क नहीं दिया गया है, तो यह डिफ़ॉल्ट होगा .)
[ के लिए वैकल्पिक रेगेक्स तर्क शुरू करता है r
(?![aeiouy])\w regex y को छोड़कर किसी भी व्यंजन वर्ण से मेल खाता है (दुर्भाग्य से JavaScript वर्ण वर्ग घटाव की अनुमति नहीं देता है)
]आमतौर पर के लिए वैकल्पिक रेगेक्स तर्क समाप्त होता है r, लेकिन हमें इसकी आवश्यकता नहीं है क्योंकि यह अंतिम फ़ंक्शन और अंतिम तर्क है

— MCMastery
स्रोत

1

मतलाब, 67 वर्ण

एक इनपुट के लिए 'this is a string of- stuff.'

s=input('','s');si=regexp(s,'[b-df-hj-np-tv-xz]');s(si)=s(flip(si))

पैदा करता है s = ffit is a fgnirt os- ssuht.

siइनपुट स्ट्रिंग में व्यंजन का सूचक है। अंतिम कथन उन पात्रों को समान वर्णों के साथ बदलता है लेकिन अनुक्रमण द्वारा उलटा क्रम।

— sintax
स्रोत

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

— स्वेवर

1

इसके अलावा आप flipस्ट्रिंग को उल्टा करने के लिए उपयोग कर सकते हैं ।

— स्वेवर

मेरे पोस्ट करने के बाद विराम चिह्नों को संपादित किया गया था, लेकिन मैं इसे ठीक कर दूंगा। इनपुट के संबंध में, क्या मैं अभी उपयोग कर सकता हूं ans, क्योंकि मैटलैब कंसोल के लिए एक डिफ़ॉल्ट इनपुट किसको सौंपा गया है?

— सिंटेक्स

1

मुझे ऐसा नहीं लगता। यह एक आत्म निहित समाधान होना चाहिए। आपको यह करने की आवश्यकता होगी s=input('')या किसी भी तरह से इसे एक गुमनाम समारोह में तैयार करना होगा@(s)

— स्वेवर

ठीक है, मैं बाद में या कल करूँगा। मैं अब अपने कंप्यूटर से दूर हूँ।

— 19

1

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

-join(($a=$args|% t*y)|%{if($_-in($c=$a-match'[^\W\d_aeiouy]')){$_=$c[--$i]};$_})

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

कम गोल्फ वाला:

$a          = $args|% toCharArray
$consonants = $a-match'[^\W\d_aeiouy]'
$result     = $a|%{if($_-in$consonants){$_=$consonants[--$i]};$_}
-join($result)

पावरशेल , 88 बाइट्स, -f

$i=0;-join($args|% t*y|%{if($_-match'[^\W\d_aeiouy]'){$c=,$_+$c;$_="{$i}";$i++};$_})-f$c

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

— Mazzy
स्रोत

0

क्यू / केडीबी +, ४५ बाइट्स

उपाय:

{x[w]:x(|)w:(&)max x=/:.Q.a except"aeiouy";x}

स्पष्टीकरण:

व्यंजन के सूचक ढूंढें, और उन्हें बदले हुए व्यंजन से बदलें:

{x[w]:x reverse w:where max x=/:.Q.a except "aeiouy";x} / ungolfed
{                                                   ; } / two-statement lambda
                                .Q.a except "aeiouy"    / alphabet (a..z) except vowels
                            x=/:                        / equals each-right (returns boolean lists where input is each a consonant)
                        max                             / 'or' the results together
                  where                                 / indices where results are true
                w:                                      / save in variable w
        reverse                                         / reverse this list
      x                                                 / index into input at these indices
 x[w]:                                                  / assign values to x at indices w
                                                     x  / return x

टिप्पणियाँ:

मेरे पास व्यंजन सूची बनाने के 3 तरीके थे, समाधान में एक विकल्प से थोड़ा बेहतर है:

"bcdfghjklmnpqrstvwxz" 22 वर्णों के लिए (सबसे उबाऊ)
.Q.a _/0 3 6 11 16 19 21 वर्णों के लिए (थोड़े शांत, प्रत्येक सूचकांक को छोड़ें)
.Q.a except"aeiouy" 19 वर्णों के लिए (दूसरा सबसे उबाऊ)

— streetster
स्रोत

0

Jq 1.5 , 289 263 बाइट्स

def C:"bcdfghjklmnpqrstvwxz";. as$s|[("^","")as$p|[match("([\($p)\(C)]+)";"g").captures[].string]]|.[1]|=(reduce map(length)[]as$l({s:add|explode|reverse|implode,r:[]};.r+=[.s[0:$l]]|.s=.s[$l:])|.r)|if$s[0:1]|inside(C)then[.[1,0]]else . end|transpose|map(add)|add

व्याख्या

def consonants:"bcdfghjklmnpqrstvwxz";

  . as $s
| [  ("^","") as $p                                              # parse string onto non-consonant
   | [match("([\($p)\(consonants)]+)";"g").captures[].string]]   # and consonant groups
| .[1] |= (
     reduce map(length)[] as $l (                                # build new for consonant groups
       {s:add|explode|reverse|implode,r:[]}                      # by adding groups from reversed string
     ; .r+=[.s[0:$l]] | .s=.s[$l:]                               
     )
     |.r
  )
| if $s[0:1]|inside(consonants) then  [.[1,0]] else . end        # put groups into proper order for merge
| transpose | map(add) | add                                     # merge groups into final string

नमूना चला

$ jq -MRr 'def C:"bcdfghjklmnpqrstvwxz";. as$s|[("^","")as$p|[match("([\($p)\(C)]+)";"g").captures[].string]]|.[1]|=(reduce map(length)[]as$l({s:add|explode|reverse|implode,r:[]};.r+=[.s[0:$l]]|.s=.s[$l:])|.r)|if$s[0:1]|inside(C)then[.[1,0]]else . end|transpose|map(add)|add' input
a sect sate
nedl-lowe
setenne sne cohtosarvr

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

— jq170727
स्रोत

0

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

s->s.format(s.replaceAll("[^\\W\\d_aeiouy]","%s"),s.chars().mapToObj(c->""+(char)c).filter(c->c.matches("[^\\W\\d_aeiouy]")).reduce("",(x,y)->y+x).split(""))

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

नोट: संकलक को स्ट्राइडर को चेतावनी देता है।
स्पष्टीकरण:

s->                                                    // Lambda function
    s.format(                                          // Format a string using the given arguments
        s.replaceAll("[^\\W\\d_aeiouy]","%s"),         // Generate the format string by replacing all consonants with "%s"
        s.chars()                                      // Stream the characters of the input string s
            .mapToObj(c->""+(char)c)                   // Map characters back to strings
            .filter(c->c.matches("[^\\W\\d_aeiouy]"))  // Filter out vowels and symbols
            .reduce("",(x,y)->y+x)                     // Build the string of consonants in reverse
            .split("")                                 // Turn into an array of single-char strings (varargs abuse)
    )                                                  // Implicit return of the formatted string

झूठ नहीं बोलने वाला, मेरा एकमात्र लक्ष्य इस उत्तर को हराना था

— बेंजामिन अर्कहार्ट
स्रोत

0

एपीएल (डायलॉग एक्सटेंडेड) , 22 बाइट्स

⌽@(('aeiou'~⍨∘⌊⎕A)∊⍨⊢)

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

— voidhawk
स्रोत

व्यंजन को उलट दें

रेटिना, 22 21 20 17

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

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

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

जावास्क्रिप्ट ईएस 6, 82 81 80 78 बाइट्स

परिक्षण

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

पाइके, 18 बाइट्स

GNU सेड, 73

जे, 53 बाइट्स

प्रयोग

व्याख्या

MATL, 18 22 21 बाइट्स

पर्ल 5 (58 + 4 = 62 बाइट्स)

व्याख्या

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

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

पर्ल 5, 92 68 55 बाइट्स

पायथ, 26 25 24 23 बाइट्स

जूलिया, 53 बाइट्स

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

जावा, 319 305 261 188 बाइट्स

Ungolfed

रूबी, 53 50 बाइट्स

पायथन 2, 103 98 100 बाइट्स

आर, 120 बाइट्स

एपीएलएक्स, 31 बाइट्स

पायथन 2.7, 144 बाइट्स

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

हास्केल, 157 131 बाइट्स

एस-लैंग ,17 16 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

स्पष्टीकरण:

मतलाब, 67 वर्ण

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

पावरशेल , 88 बाइट्स, -f

क्यू / केडीबी +, ४५ बाइट्स

Jq 1.5 , 289 263 बाइट्स

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

एपीएल (डायलॉग एक्सटेंडेड) , 22 बाइट्स