इनपुट

उदाहरण के लिए मुद्रण योग्य ASCII वर्णों की एक स्ट्रिंग:

This is an example string.

उत्पादन

प्रत्येक व्यंजन के लिए ( BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz) जो स्वर के बाद नहीं है ( AEIOUaeiou) अंतिम स्वर को इससे पहले जोड़ें, लोअरकेस में।
पहले स्वर के पहले व्यंजन इस प्रकार हैं :

Thisi isi ana examapale seterinigi.

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

AN EXAMPLE WITH A LOT UPPERCASE (plus some lowercase)
=> ANa EXAMaPaLE WITiHi A LOTo UPuPEReCASE (pelusu some lowerecase)

And here comes a **TEST** case with 10% symbols/numbers(#)!
=> Anada here comese a **TESeTe** case witihi 10% siyimiboloso/numuberese(#)!

This is an example string.
=> Thisi isi ana examapale seterinigi.

abcdefghijklmnopqrstuvwxyz
=> abacadefegehijikiliminopoqorosotuvuwuxuyuzu

A pnm bnn
=> A panama banana

Tell me if you need more test cases!
=> Telele me ifi you neede more tesete casese!

स्कोरिंग

जैसा कि यह कोड-गोल्फ है , प्रत्येक भाषा में सबसे कम बाइट-काउंट वाला उत्तर जीतता है (कोई उत्तर स्वीकार नहीं किया जाएगा)।

code-golf string

— wastl
स्रोत

तो, क्या सम्मिलित स्वर हमेशा निचला होना चाहिए, जबकि पाठ अपरकेस और लोअरकेस दोनों हो सकता है?

— आउटगोल्फर

क्या आउटपुट एक सूची / सरणी के रूप में हो सकता है?

— नाथन डिम्मर

@EriktheOutgolfer हां, मुझे ऐसा अपरकेस नहीं चाहिए था, जहां हमें लोअरकेस की जरूरत हो, लेकिन यह चुनौती को ओवरप्ले कर देता यदि किसी को आसन्न अक्षरों के मामले की जांच

— करनी होती

11

स्वस्थ बच्चे खाएं, कोशिश करें A pnm bnn!

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

4

क्या किसी और को लगता है कि "इटालियंस" को कहीं शीर्षक में जाने की आवश्यकता है?

— आर्टिलियस

14

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

i`(?<=([aeiou]).*?[^\W\d_aeiou])(?![aeiou])
$l$1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: लुकहैड एक बिंदु के लिए खोज करता है जिसके बाद एक स्वर नहीं होता है, जबकि लुकबाइंड तुरंत पूर्ववर्ती व्यंजन और पिछले स्वर की खोज करता है, जिसे बाद में निचले मामले में डाला जाता है।

— नील
स्रोत

8

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

(@ बग्घी के लिए 3 बाइट्स को सहेजा गया।)

f=s=>(t=(s+=' ').replace(/[aeiou]|[a-z][^aeiou]/ig,r=>r[1]?r[0]+v.toLowerCase()+r[1]:v=r,v=''))!=s?f(t):s

निम्नलिखित स्वरों के साथ स्वर या व्यंजन के लिए खोजें :

/[aeiou]|[a-z][^aeiou]/ig

(हमें व्यंजन के लिए स्पष्ट रूप से खोज करने की आवश्यकता नहीं है, क्योंकि स्वरों को इसके आधार पर बाहर रखा गया है /[aeiou]|...।)

स्वरों को संगृहीत किया जाता है v, और व्यंजन जिनके बिना निम्नलिखित स्वर नहीं vडाले गए हैं:

r[1]?r[0]+v.toLowerCase()+r[1]:v=r

(यदि r[1]मौजूद है, तो हमने एक व्यंजन प्लस गैर-स्वर पर मिलान किया है।)

यदि कुछ भी नहीं बदला गया है, तो हम इनपुट वापस करते हैं। अन्यथा, हम बदले हुए स्ट्रिंग पर पुनरावृत्ति करते हैं।

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

f=s=>(t=(s+=' ').replace(/[aeiou]|[a-z][^aeiou]/ig,r=>r[1]?r[0]+v.toLowerCase()+r[1]:v=r,v=''))!=s?f(t):s

console.log(f('A pnm bnn'));
console.log(f('abc'));
console.log(f('AN EXAMPLE WITH A LOT UPPERCASE (plus some lowercase)')); 
console.log(f('And here comes a **TEST** case with 10% symbols/numbers(#)!'));
console.log(f('This is an example string.'));
console.log(f('abcdefghijklmnopqrstuvwxyz'));
console.log(f('Tell me if you need more test cases!'));

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

— रिक हिचकॉक
स्रोत

1

यह और भी बेहतर है। मुझे वास्तव में रेगेक्स

— लुइस फेलिप डी जीसस मुनोज

+1 स्मार्ट आइडिया ओवर मैप में शामिल होने का उपयोग करने के लिए +

— Join

बिना पुनरावृत्ति के आपके (लगभग) कार्यशील संस्करण के आधार पर: s=>s.replace(/[aeiou][^a-z]*([a-z](?![aeiou]))+/gi,s=>s.replace(/(?!^)./g,a=>a+s[0].toLowerCase()))मुझे गैर-अक्षरों के दृश्यों के साथ कोई समस्या नहीं है, हालांकि

— 20

पुनरावृत्ति निश्चित रूप से यहां चीजों को सरल बनाती है।

— रिक हिचकॉक

(s+=' ')कुछ बाइट्स बचाना चाहिए।

— झबरा

5

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

def f(s,v=''):u=s[:1];return s and u+v*(u.isalpha()-g(u)-g((s+u)[1]))+f(s[1:],[v,u.lower()][g(u)])
g='aeiouAEIOU'.count

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

संपादित करें: लिन को 15 बाइट्स

— चास ब्राउन
स्रोत

मैंने इसके साथ 119 बाइट्स के लिए थोड़ा फिड किया ।

— लिन

@ लीन: द लव <vowels>.count।

— चास ब्राउन

4

मानक एमएल , 225 223 बाइट्स

str o Char.toLower;fun?c=String.isSubstring(it c)"aeiou"fun g(x,l)$d=(fn l=>if Char.isAlpha$andalso not(?d)then if? $then(it$,l)else(x,l^x)else(x,l))(l^str$)fun f$(c::d::r)=f(g$c d)(d::r)|f$[c]= #2(g$c c);f("","")o explode;

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

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

val lower = str o Char.toLower

fun isVowel c = String.isSubstring (lower c) "aeiou"

(* c is the current char, d is the next char, x is the last vowel and l the accumulator 
   for the resulting string *)
fun g (x,l) c d = 
    if Char.isAlpha c andalso not (isVowel d)
    then if isVowel c 
         then (lower c, l^str c)
         else (x, l^str c^x)
    else (x, l^str c)

fun f t (c::d::r) = f (g t c d) (d::r)
  | f t [c] = #2(g t c #"d")

val h = f ("","") o explode;

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

— Laikoni
स्रोत

वाह, एमएल गोल्फ वास्तव में दिलचस्प लग रहा है! मैं प्यार करता हूं itऔर $चर नाम का उपयोग करता हूं ।

— लिन

@ लियन ने कुछ समय पहले नाम बदलने वाले के बारे में एक टिप लिखी थी और एक के बारे itमें भी लिखने की योजना बनाई थी , लेकिन अभी तक ऐसा नहीं किया है।

— लकोनी

4

sed 4.2.2 , 64 बाइट्स

:
s/(([aeiou])[^a-z]*[b-df-hj-np-tv-z])([^aeiou]|$)/\1\l\2\3/I
t

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

— कर्नेल पैनिक
स्रोत

मैं ईमानदार रहूँगा, यहाँ मेरा लक्ष्य सिर्फ एक-एक बाइट्स द्वारा पेरी को हराने की कोशिश करना है। देखते हैं कि क्या यह पकड़ रखता है :)

— कर्नेलपैनिक

4

पर्ल 5, 68 67 59 बाइट्स

perl -pe '$v="[aeiou])";1while s/($v[^a-z]*[b-z]\K(?<!$v(?!$v/\L$1/i'

यहाँ की उपयोगिता का एक बड़ा उदाहरण है \K, और मुझे विश्वास नहीं हो रहा है कि डोम हेस्टिंग्स ने इसे इंगित करने से पहले मुझे इस सुविधा के बारे में नहीं पता था।

मैं सिर्फ इस्तेमाल करने के साथ सही व्यवहार नहीं कर पाया s///g, इसलिए एक वास्तविक लूप आवश्यक लगता है। (यह संभव है कि एक नज़र के पीछे के दावे का सही उपयोग बिना किसी स्पष्ट कार्य के हो सकता है while- लेकिन मैंने इसे नहीं पाया है।)

— रोटी का डिब्बा
स्रोत

अच्छा तरीका! कुछ बेहतर करने में सक्षम नहीं था, लेकिन 6 बाइट्स प्राप्त करने में कामयाब रहा: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

1

@DomHastings: यहां तक कि छोटी (58 बाइट्स तक) [aeiou])वेरिएबल से फैक्टरिंग करके : इसे ऑनलाइन आज़माएं!

— शैडो रेंजर

3

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

@ बाइट के लिए 8 बाइट्स बचाता है

s=>[x="",...s].map((i,j)=>(r=/[aeiou]/i).test(i)?x=i:/[a-z]/i.test(i)&&!r.test(s[j]||1)?i+x.toLowerCase():i).join``

मैं इसे O_o को गोल्फ की प्रक्रिया में और अधिक बढ़ाने में कामयाब रहा हूं, लेकिन यह एक बग को भी ठीक करता है

s=>[x="",...s].map(             // Create a new array with x storing last vowel
                                // This also offsets indexes by one so rel to original str refers to next char
   (i,j)=>                      // Going through each char...
      (r=/[aeiou]/i).test(i)?   // If it's vowel, store it in x
          x=i:
      /[a-z]/i.test(i)          // If a letter (thats not a vowel excluded by above)
         &&!r.test(s[j]||1)?    // Test if next char is *not* vowel
         i+x.toLowerCase():i    // If it isn't, then add the most recent vowel after
    ).join``                    // Combine back to string

— Downgoat
स्रोत

@ रीचेक ओह शूट पूरी तरह से चार को खत्म करने के बारे में भूल गया, asap फिक्सिंग

— डाउनगेट

1

@ हिचकीकॉक ठीक तय

— डाउन एंजेट

आह, हाँ गोल्फ @ETHproductions के लिए धन्यवाद

— डाउन

3

जावास्क्रिप्ट, 88 82 बाइट्स

एक नियमित अभिव्यक्ति के साथ किया:

मूल संस्करण (88 बाइट्स):

s=>s.replace(/(?<=([aeiou]).*?(?![aeiou])[a-z])(?=[^aeiou]|$)/gi,(_,c)=>c.toLowerCase())

नील की नियमित अभिव्यक्ति को देखने के बाद अपडेट किया गया संस्करण (82 बाइट्स) :

s=>s.replace(/(?<=([aeiou]).*?[^\W\d_aeiou])(?![aeiou])/gi,(_,c)=>c.toLowerCase())

var tests = {
  "AN EXAMPLE WITH A LOT UPPERCASE (plus some lowercase)":
    "ANa EXAMaPaLE WITiHi A LOTo UPuPEReCASE (pelusu some lowerecase)",
  "And here comes a **TEST** case with 10% symbols/numbers(#)!":
    "Anada here comese a **TESeTe** case witihi 10% siyimiboloso/numuberese(#)!",
  "This is an example string.":
     "Thisi isi ana examapale seterinigi.",
  "abcdefghijklmnopqrstuvwxyz":
    "abacadefegehijikiliminopoqorosotuvuwuxuyuzu",
  "A pnm bnn":
     "A panama banana",
  "Tell me if you need more test cases!":
     "Telele me ifi you neede more tesete casese!"
};

for ( test in tests )
{
  var result = (s=>s.replace(/(?<=([aeiou]).*?[^\W\d_aeiou])(?![aeiou])/gi,(_,c)=>c.toLowerCase()))(test);
  console.log( result === tests[test], result );
}

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

— MT0
स्रोत

3

जाप `-P` , 28 बाइट्स

ó@\ctX ©\VtYÃËè\v ?P=D:D¬qPv

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

अनपैक्ड और यह कैसे काम करता है

UóXY{\ctX &&\VtY} mD{Dè\v ?P=D:Dq qPv

UóXY{           }  Split the string between any two chars that don't satisfy...
     \ctX &&\VtY     The first char is a consonant and the second is a non-vowel
mD{                And map...
   Dè\v              If this item is a vowel...
       ?P=D            Assign it to P and return as-is
           :Dq qPv     Otherwise, split the item into chars and join with P lowercased
                       (P starts with "", so beginning consonants are not affected)

-P                 Join with ""

óसमारोह regexes के किसी भी प्रकार से अधिक जीतता है।

— bubbler
स्रोत

एक अच्छा, मुझे हरा: डी।

— मैजिक ऑक्टोपस Urn

अच्छी तरह से किया - मैंने इस एक के साथ खुद को गंभीर दिमागी कसरत दी!

— झबरा

2

जावास्क्रिप्ट (Node.js) , 146 143 132 127 125 बाइट्स

(a,v="")=>[...a].map((b,i)=>(w=/[aeiou]/i).test(b)&&(v=b)?b:w.test(a[i+1]||b)||!b.match(/[a-z]/i)?b:b+v.toLowerCase()).join``

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

2

पर्ल 6 , 75 73 71 69 बाइट्स

{({S:i/.*(<[aeiou]>).*<-[\W\d_aeiou]><()><![aeiou]>/$0.lc()/}...*eq*).tail}

कोशिश करो

{({S:i{.*(<[aeiou]>).*<-[\W\d_aeiou]><()><![aeiou]>}=$0.lc}...*eq*).tail}

कोशिश करो

{({S:i{.*(<[aeiou]>).*<:L-[_aeiou]><()><![aeiou]>}=$0.lc}...*eq*).tail}

कोशिश करो

{({S:i{.*(<[aeiou]>).*<:L-[_aeiou]><(<![aeiou]>}=$0.lc}...*eq*).tail}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter $_

  (
    # generate a sequence

    {  # code block used to generate the values

      S               # substitute (not in-place)
      :i              # :ignorecase
      {

          .*              # start at end of string

          ( <[aeiou]> )   # store the previous vowel in $0

          .*

          <:L - [_aeiou]> # letter other than a vowel

          <(              # ignore everything before this

                          # this is where `$0.lc` gets inserted

          # )>            # ignore everything after this

          <![aeiou]>      # not a vowel (zero width lookahead)

      } = $0.lc       # replace with lowercase of the earlier vowel
    }

    ...    # keep generating until:

    * eq * # there are two equal strings (no changes)

  ).tail   # get the last value
}

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

2

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

lambda s,v='[^aeiouAEIOU':sub(f'(?<={v}\W\d])(?={v}]|$)',lambda m:sub(f'{v}]','',s[:m.end()])[-1:].lower(),s)
from re import*

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

पायथन 3.6 हमें (ab) स्वरों के हमारे समुच्चय के पुन: उपयोग के लिए f- स्ट्रिंग्स का उपयोग करने की अनुमति देता है (और चार और पात्रों को बचाने के लिए, एक औंधा regex वर्ण वर्ग की शुरुआत) सस्ते में ( fप्रत्येक स्ट्रिंग पर एक उपसर्ग, फिर {v}जरूरत के बजाय, '+v+'आपको संघनन की आवश्यकता होगी, या [^aeiouAEIOUआप शाब्दिक रूप से सम्मिलित करेंगे।

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

आंशिक रूप से डी-गोल्फ, यह कुछ इस तरह होगा:

import re

def get_last_vowel(string):
    '''
    Returns the lowercase version of the last vowel in a string if
    the string contains any vowels, otherwise, return the empty string
    '''
    try:
        *restvowels, lastvowel = re.sub(r'[^aeiouAEIOU]', '', string)
    except ValueError:
        lastvowel = ''  # No vowels in string
    return lastvowel.lower()

def rememebere_tehe_vowelese(string):
    '''Inserts the lowercased last vowel seen after any consonant not followed by a vowel'''
    return re.sub(r'(?<=[^aeiouAEIOU\W\d])(?=[^aeiouAEIOU]|$)',
                  lambda match: get_last_vowel(string[:match.end()]),
                  string)

— ShadowRanger
स्रोत

2

TSQL, 500 बाइट्स

 CREATE TABLE i (i CHAR(999)); INSERT i VALUES ('The rain in Spain stays mainly in the plain')
 DECLARE @w CHAR(999)=(SELECT i FROM i),@r VARCHAR(999)='';WITH d(n,c,i,q)AS(SELECT n,SUBSTRING(@w,n,1),CHARINDEX(SUBSTRING(@w,n,1),'AEIOUaeiou'),CHARINDEX(SUBSTRING(@w,n,1),'BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz')FROM(SELECT DISTINCT number n FROM master..[spt_values]WHERE number BETWEEN 1 AND LEN(@w))D)SELECT @r=@r+f.c+LOWER(COALESCE(CASE WHEN f.q<>0 AND COALESCE(d2.i,0)=0 THEN SUBSTRING(@w,(SELECT MAX(n)FROM d WHERE i<>0 AND n<f.n),1)END,''))FROM d f LEFT JOIN d d2 ON f.n=d2.n-1 SELECT @r

तालिका iका उपयोग इनपुट के लिए किया जाता है

— जान ड्रोजेन
स्रोत

2

इनपुट को एक निश्चित चर में मौजूद मान लेना आमतौर पर अनुमति नहीं है । क्या इसके बजाय एक फ़ंक्शन होने के लिए अनुकूलित किया जा सकता है?

— लकोनी

@ लिकोनी समाधान दिए गए नियमों से मेल खाने के लिए अद्यतन

— Jan Drozen

2

एसडब्ल्यूआई-प्रोलॉग, 593 बाइट्स

a(S,D):-atom_chars(S,D).
g(_,[],_,-1).
g(E,[E|_],R,R).
g(E,[_|T],I,R):-N is I+1,g(E,T,N,R).
c(A,E):-g(E,A,0,R),R > -1.
v(X):-a('AEIOUaeiou',X).
c(X):-a('BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz',X).
d([_],_,R,R).
d([H|T],_,I,R):-v(V),c(V,H),!,d(T,H,I,[H|R]).
d([H,N|T],V,I,R):-c(C),c(C,H),v(W),c(W,N),!,d([N|T],V,I,[H|R]).
d([H,N|T],V,I,R):-c(C),c(C,H),v(W),\+c(W,N),string_lower(V,LV),!,d([N|T],V,I,[LV,H|R]).
d([H|T],V,I,R):-!,d(T,V,I,[H|R]).
r([],Z,Z).
r([H|T],Z,A):-r(T,Z,[H|A]).
r(S,D):-r(S,D,[]).
m(X,R):-a(X,O),r(O,P),r([''|P],Q),d(Q,'',I,[]),r(I,J,[]),atomic_list_concat(J,R).

केवल अंतर्निहित predicates (regex या सूची हेरफेर लाइब्रेरी के बिना) में उपयोग किया जाता है।

उपयोग:

?- m('A pnm bnn').
'A panama banana'
true .

— जान ड्रोजेन
स्रोत

2

हास्केल , 142 130 बाइट्स

""&
import Data.Char
v=(`elem`"aeiouAEIOU")
s&(x:y:z)|v y=x:s&(y:z)
s&(x:y)|v x=x:[toLower x]&y|isAlpha x=x:s++s&y|1>0=x:s&y
_&x=x

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

प्रारंभिक बाद में परिभाषित फ़ंक्शन ""&का एक आंशिक अनुप्रयोग है (&), और TIO को बाइट्स में गिनने के लिए इतनी अजीब तरह से रखा गया है ""&, लेकिन बाइट्स की गणना नहीं करते हैं, जो एक पूर्ण कार्यक्रम में, किसी भी नामित मान को असाइन करने के लिए आवश्यक होगा।

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

import Data.Char (isAlpha, toLower)

vowel :: Char -> Bool
vowel = (`elem`"aeiouAEIOU")

replace :: String -> String
replace = go "" -- start by carrying no extra vowel
  where go _ "" = ""
        -- special case for "anything followed by vowel" so later cases can ignore next character
        go s (x:y:more) | vowel y = x : go s (y:more)
        go s (x:xs) | vowel x = x : go [toLower x] xs -- update the vowel we're carrying
                    | isAlpha x = x : s ++ go s xs -- non-vowel letter not followed by a vowel
                    | otherwise = x : go s xs -- some non-letter junk, just include it and carry on

वास्तव में पुनरावृत्ति के बजाय एक गुना के साथ इसे और अधिक स्पष्ट रूप से करने का एक तरीका होना चाहिए, लेकिन मैं इसका पता नहीं लगा सका।

— amalloy
स्रोत

यहाँ हैडर को परिभाषित करने का एक बहुत ही आसान तरीका fहै जो शरीर में दिखाई नहीं देता है: इसे ऑनलाइन आज़माएं!

— लकोनी

इसमें दो अनावश्यक स्थान हैं v = (और आप इनफ़िक्स ऑपरेटर केg रूप में परिभाषित कर सकते हैं ।

— लाइकोनी

आधार स्थिति g _""=""को अंतिम स्थिति g _ x=xमें रखना एक बाइट को बचाता है: (दो बाइट्स यदि आप लाईकोनी के रूप में इन्फिक्स में स्विच करते हैं)।

— निमि

हमारे सम्मेलनों के अनुसार ""&, इसे बनाने के लिए आपको कोष्ठक जोड़ना होगा ।

— लकोनी

1

05AB1E , 34 बाइट्स

vyžMylåil©1V}žPylåžM¹N>èå_Y&&i®«}J

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

मुझे लगता है कि मैं इस राक्षसी से केवल 3 बाइट्स दाढ़ी ले सकता हूं ... मुझे लगता है कि मैं नीचे बूलियन दाढ़ी कर सकता हूं, लेकिन 3 मामले होने चाहिए। स्वरों के लिए 1। व्यंजन के लिए 1। 1 इस मामले के लिए कि एक अंक / प्रतीक मौजूद है।

v                                 # For each...
 y                                # Push current element.
  žM                              # Push lower-case vowels (aeiou).
    ylå                           # Lower-case current element is vowel?
       i©1V}                      # If so, put it in register, set Y to 1.
            žP                    # Push lower-case consonants (b...z)
              ylå                 # Is current char a consonant?
                 žM¹N>èå_         # Push vowels again, is input[N+1] NOT a vowel? 
                         Y        # Did we ever set Y as 1?
                          &&      # All 3 previous conditions true?
                            i®«}  # Concat the current vowel to the current char.
                                J # Join the whole stack.
                                  # '}' isn't needed here, b/c it's implied.
                                  # Implicit return.

— जादू ऑक्टोपस Urn
स्रोत

0

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

नील की नियमित अभिव्यक्ति के आधार पर ।

[regex]::Replace($args,'(?i)(?<=([aeiou]).*?[^\W\d_aeiou])(?![aeiou])',{"$($args.Groups[1])".ToLower()})

यह के रूप में बचाने के लिए get-rememebere.ps1। परीक्षण के लिए स्क्रिप्ट:

$test = @"
AN EXAMPLE WITH A LOT UPPERCASE (plus some lowercase)
And here comes a **TEST** case with 10% symbols/numbers(#)!
This is an example string.
abcdefghijklmnopqrstuvwxyz
A pnm bnn
Tell me if you need more test cases!
"@

$expected = @"
ANa EXAMaPaLE WITiHi A LOTo UPuPEReCASE (pelusu some lowerecase)
Anada here comese a **TESeTe** case witihi 10% siyimiboloso/numuberese(#)!
Thisi isi ana examapale seterinigi.
abacadefegehijikiliminopoqorosotuvuwuxuyuzu
A panama banana
Telele me ifi you neede more tesete casese!
"@

$result = .\get-rememebere.ps1 $test
$result -eq $expected
$result

— Mazzy
स्रोत

1

क्या यह केवल एक स्निपेट नहीं है? मेरा मतलब है, पॉलीशेल में इनपुट है, इसलिए आप यह नहीं मान सकते हैं कि इनपुट में है $t। प्रासंगिक मेटा पोस्ट: codegolf.meta.stackexchange.com/a/8731/78123

— wastl

0

लाल , 276 बाइट्स

func[s][v: charset t:"AEIOUaeiou"c: charset 
u:"BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz"b:
parse s[collect[any keep[thru c opt v]keep thru end]]p:""foreach
c b[either find t e: last c: to-string c[p: e][parse c[any[copy p v
| skip]]if find u e[append c lowercase p]]prin c]]

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

पठनीय:

f: func [ s ] [
   v: charset t: "AEIOUaeiou"
   c: charset u: "BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz"
   b: parse s [
       collect [ any keep [ thru c opt v ]
       keep thru end ]
   ]
   p: "" 
   foreach c b [
       e: last c: to-string c
       either find t e [ p: e ][
           parse c [ any [ copy p v | skip ] ]
           if find u e [ append c lowercase p ]
       ]
       prin c
   ]
]

— गैलेन इवानोव
स्रोत

0

याबेसिक , 180 बाइट्स

एक पूरा कार्यक्रम जो STDIN से इनपुट लेता है और STDOUT को आउटपुट देता है

Line Input""s$
x$="AEIOUaeiou"
For i=1To Len(s$)
c$=Mid$(s$,i,1)
?c$;
If InStr(x$,c$)Then
v$=c$
Else
a=Asc(Upper$(c$))
If a>64And a<91And!InStr(x$,Mid$(s$,i+1,1))Then?v$;Fi
Fi
Next

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

— टेलर स्कॉट
स्रोत

स्मरण करें तेह स्वर!

इनपुट

उत्पादन

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

स्कोरिंग

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

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

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

मानक एमएल , 225 223 बाइट्स

sed 4.2.2 , 64 बाइट्स

पर्ल 5, 68 67 59 बाइट्स

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

जावास्क्रिप्ट, 88 82 बाइट्स

जाप -P , 28 बाइट्स

अनपैक्ड और यह कैसे काम करता है

जावास्क्रिप्ट (Node.js) , 146 143 132 127 125 बाइट्स

पर्ल 6 , 75 73 71 69 बाइट्स

विस्तारित:

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

TSQL, 500 बाइट्स

एसडब्ल्यूआई-प्रोलॉग, 593 बाइट्स

हास्केल , 142 130 बाइट्स

05AB1E , 34 बाइट्स

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

लाल , 276 बाइट्स

याबेसिक , 180 बाइट्स

जाप `-P` , 28 बाइट्स