Đầu vào

Một chuỗi các ký tự ASCII có thể in được, ví dụ:

This is an example string.

Đầu ra

Đối với mọi phụ âm ( BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz) không được theo sau bởi một nguyên âm ( AEIOUaeiou) thêm nguyên âm cuối trước nó, bằng chữ thường.
Phụ âm trước nguyên âm đầu tiên được để nguyên trạng :

Thisi isi ana examapale seterinigi.

Các trường hợp thử nghiệm

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!

Chấm điểm

Vì đây là môn đánh gôn , câu trả lời có số byte thấp nhất trong mỗi ngôn ngữ sẽ thắng (không có câu trả lời nào được chấp nhận).

Võng mạc , 48 byte

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

Hãy thử trực tuyến! Giải thích: Lookahead tìm kiếm một điểm không theo nguyên âm, trong khi lookbehind tìm kiếm một phụ âm ngay trước và nguyên âm trước, sau đó được chèn vào chữ thường.

JavaScript (ES6), 108 105 byte

(Đã lưu 3 byte nhờ @Shaggy.)

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

Tìm kiếm nguyên âm hoặc phụ âm không có nguyên âm sau:

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

(Chúng tôi không cần tìm kiếm phụ âm một cách rõ ràng, vì nguyên âm được loại trừ dựa trên /[aeiou]|....)

Nguyên âm được lưu trữ vvà các phụ âm không có nguyên âm sau vđược chèn vào:

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

(Nếu r[1]tồn tại, chúng tôi đã kết hợp trên một phụ âm cộng với nguyên âm không.)

Nếu không có gì thay đổi, chúng tôi trả lại đầu vào. Mặt khác, chúng tôi lặp lại trên chuỗi thay thế.

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!'));

Python 2 , 134 119 byte

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

Hãy thử trực tuyến!

EDIT: 15 byte thx cho Lynn

ML chuẩn , 225 223 byte

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;

Hãy thử trực tuyến!

Ít chơi gôn hơn:

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;

Hãy thử trực tuyến!

sed 4.2.2 , 64 byte

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

Hãy thử trực tuyến!

Perl 5, 68 67 59 byte

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

Đây là một ví dụ tuyệt vời về sự hữu ích của \Kvà tôi không thể tin rằng mình không biết về tính năng này trước khi Dom Hastings chỉ ra.

Tôi đã không thể có được hành vi đúng chỉ với việc sử dụng s///g, vì vậy một vòng lặp thực sự có vẻ cần thiết. (Có thể việc sử dụng đúng một xác nhận nhìn phía sau có thể hoạt động mà không rõ ràng while- nhưng tôi không tìm thấy nó.)

JavaScript ES6, 115 byte

Tiết kiệm 8 byte nhờ @ETH sản phẩm

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``

Tôi đã cố gắng thổi phồng điều này nhiều hơn trong quá trình chơi golf O_o nhưng nó cũng sửa một lỗi

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

JavaScript, 88 82 byte

Thực hiện với một biểu thức chính quy duy nhất:

Phiên bản gốc (88 byte):

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

Phiên bản cập nhật (82 byte) sau khi xem biểu thức chính quy của Neil :

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 );
}

Japt -P , 28 byte

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

Hãy thử trực tuyến!

Giải nén & Cách thức hoạt động

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 ""

Các óchức năng thắng hơn bất kỳ loại regexes.

JavaScript (Node.js) , 146 143 132 127 125 byte

(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``

Hãy thử trực tuyến!

Perl 6 ,  75 73 71  69 byte

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

Thử nó

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

Thử nó

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

Thử nó

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

Thử nó

Mở rộng:

{  # 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
}

Python 3 , 125 byte

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

Hãy thử trực tuyến!

Python 3.6 cho phép chúng tôi (ab) sử dụng các chuỗi f để sử dụng lại các nguyên âm của chúng tôi (và để lưu thêm bốn ký tự, bắt đầu một lớp ký tự regex đảo ngược) với giá rẻ ( thay vào đó là một ftiền tố trên mỗi chuỗi {v}, thay vào đó là cần thiết '+v+'bạn cần ghép nối hoặc [^aeiouAEIOUbạn sẽ chèn theo nghĩa đen.

Regex không khớp với các ký tự, chỉ là một vị trí, tránh các vấn đề với các kết quả không trùng lặp mà các regex thông thường yêu cầu và loại bỏ yêu cầu phản hồi bất kỳ phần nào của trận đấu; tất cả những gì chúng ta sử dụng đối tượng khớp là để lấy chỉ số lát mà chúng ta sử dụng để tìm nguyên âm trước.

Bỏ chơi một phần, nó sẽ giống như:

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)

TSQL, 500 byte

 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

Bảng iđược sử dụng cho đầu vào

SWI-Prolog, 593 byte

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).

Chỉ được sử dụng các biến vị ngữ tích hợp (không có thư viện thao tác regex hoặc danh sách).

Sử dụng:

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

Haskell , 142 130 byte

""&
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

Hãy thử trực tuyến!

Chữ cái đầu tiên ""&là một ứng dụng một phần của (&)hàm được định nghĩa sau này và được đặt rất kỳ quặc để làm cho TIO đếm các byte trong ""&, nhưng không tính các byte trong một chương trình đầy đủ, sẽ cần để gán nó cho bất kỳ giá trị được đặt tên nào.

Ít chơi gôn hơn:

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

Thực sự phải có một cách để làm điều này chính xác hơn với một nếp gấp thay vì đệ quy, nhưng tôi không thể tìm ra nó.

05AB1E , 34 byte

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

Hãy thử trực tuyến!

Tôi lấy lại điều đó Tôi chỉ có thể cạo 3 byte khỏi sự quái dị này ... Tôi nghĩ rằng tôi có thể cạo boolean xuống, nhưng PHẢI có 3 trường hợp. 1 cho nguyên âm. 1 cho phụ âm. 1 cho trường hợp tồn tại một chữ số / ký hiệu.

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.

Powershell, 104 byte

dựa trên biểu thức chính quy của Neil .

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

lưu nó như là get-rememebere.ps1. Kịch bản để thử nghiệm:

$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

Màu đỏ , 276 byte

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]]

Hãy thử trực tuyến!

Có thể đọc đượ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
   ]
]

Yabasic , 180 byte

Một chương trình đầy đủ lấy đầu vào từ STDIN và xuất ra 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

Hãy thử trực tuyến!