Eingang

Eine Zeichenfolge mit druckbaren ASCII-Zeichen, zum Beispiel:

This is an example string.

Ausgabe

Fügen Sie für jeden Konsonanten ( BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz), auf den kein Vokal ( AEIOUaeiou) folgt , den letzten Vokal davor in Kleinbuchstaben hinzu.
Konsonanten vor dem ersten Vokal bleiben unverändert :

Thisi isi ana examapale seterinigi.

Testfälle

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!

Wertung

Da dies Codegolf ist , gewinnt die Antwort mit der niedrigsten Byteanzahl in jeder Sprache (keine Antwort wird akzeptiert).

Netzhaut , 48 Bytes

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

Probieren Sie es online! Erläuterung: Der Lookahead sucht nach einem Punkt, auf den kein Vokal folgt, während der Lookbehind nach einem unmittelbar vorhergehenden Konsonanten und einem vorherigen Vokal sucht, die dann in Kleinbuchstaben eingefügt werden.

JavaScript (ES6), 108 105 Bytes

(3 Bytes dank @Shaggy gespeichert.)

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

Sucht nach Vokalen oder nach Konsonanten ohne folgenden Vokal:

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

(Wir müssen nicht explizit nach Konsonanten suchen, da Vokale auf der Basis von ausgeschlossen werden /[aeiou]|....)

Vokale werden in gespeichert vund Konsonanten ohne folgenden Vokal veingefügt:

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

(Falls r[1]vorhanden, haben wir einen Konsonanten plus Nicht-Vokal gefunden.)

Wenn nichts geändert wurde, geben wir die Eingabe zurück. Andernfalls greifen wir auf die ersetzte Zeichenfolge zurück.

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 Bytes

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

Probieren Sie es online!

EDIT: 15 Bytes danke an Lynn

Standard ML , 225 223 Bytes

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;

Probieren Sie es online!

Weniger golfen:

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;

Probieren Sie es online!

sed 4.2.2 , 64 Bytes

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

Probieren Sie es online!

Perl 5, 68 67 59 Bytes

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

Hier ist ein großartiges Beispiel für die Nützlichkeit von \Kund ich kann nicht glauben, dass ich über diese Funktion nichts wusste, bevor Dom Hastings darauf hingewiesen hat.

Ich war nicht in der Lage, mit nur der Verwendung das richtige Verhalten zu erzielen s///g, daher scheint eine tatsächliche Schleife notwendig zu sein. (Es ist möglich, dass die richtige Verwendung einer Look-Behind-Behauptung ohne eine explizite funktioniert while- aber ich habe es nicht gefunden.)

JavaScript ES6, 115 Byte

Spart 8 Bytes dank @ETHProductions

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

Ich habe es geschafft, dies mehr in den Prozess des Golfspiels O_o aufzublasen, aber es behebt auch einen Fehler

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 Bytes

Fertig mit einem einzelnen regulären Ausdruck:

Originalversion (88 Bytes):

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

Aktualisierte Version (82 Bytes) nach einem Blick auf Neils regulären Ausdruck :

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 Bytes

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

Probieren Sie es online!

Ausgepackt und wie es funktioniert

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

Die óFunktion gewinnt jede Art von Regexen.

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

Probieren Sie es online!

Perl 6 ,  75 73 71  69 Bytes

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

Versuch es

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

Versuch es

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

Versuch es

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

Versuch es

Erweitert:

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

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

Probieren Sie es online!

Mit Python 3.6 können wir F-Strings (ab) verwenden , um unseren Satz von Vokalen (und für vier weitere gespeicherte Zeichen den Beginn einer invertierten Regex-Zeichenklasse) kostengünstig wiederzuverwenden (ein fPräfix für jeden String, dann {v}nach Bedarf anstelle des '+v+'Sie müssten mit Verkettung, oder [^aeiouAEIOUSie würden buchstäblich einfügen.

Der reguläre Ausdruck, der keinen Zeichen, sondern nur einer Position entspricht, vermeidet Probleme mit den nicht überlappenden Übereinstimmungen, die normale reguläre Ausdrücke erfordern, und beseitigt die Notwendigkeit, einen Teil der Übereinstimmung rückzuverweisen. Alles, wofür wir das Match-Objekt verwenden, ist, den Slice-Index abzurufen, mit dem wir den vorherigen Vokal finden.

Teilweise entgolft, wäre es so etwas wie:

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 Bytes

 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

Die Tabelle iwird für die Eingabe verwendet

SWI-Prolog, 593 Bytes

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

Verwendet nur eingebaute Prädikate (ohne Regex- oder Listenbibliothek).

Verwendung:

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

Haskell , 142.130 Bytes

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

Probieren Sie es online!

Die Initiale ""&ist eine Teilanwendung der (&)später definierten Funktion und ist so seltsam platziert, dass TIO die Bytes zählt ""&, aber nicht die Bytes, die in einem vollständigen Programm benötigt würden, um diese einem beliebigen benannten Wert zuzuweisen.

Weniger golfen:

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

Es sollte wirklich einen Weg geben, dies mit einer Falte präziser zu machen, als mit einer Rekursion, aber ich konnte es nicht herausfinden.

05AB1E , 34 Bytes

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

Probieren Sie es online!

Ich nehme das zurück Ich kann nur 3 Bytes von dieser Monstrosität rasieren ... Ich denke, ich könnte den Booleschen nach unten rasieren, aber es MUSS 3 Fälle geben. 1 für Vokale. 1 für Konsonanten. 1 für den Fall, dass eine Ziffer / ein Symbol existiert.

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 Bytes

basierend auf Neils regulärem Ausdruck .

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

Speichern Sie es als get-rememebere.ps1. Skript zum Testen:

$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

Rot , 276 Bytes

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

Probieren Sie es online!

Lesbar:

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 Bytes

Ein vollständiges Programm, das Eingaben von STDIN übernimmt und an STDOUT ausgibt

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

Probieren Sie es online!