[Question]
  [
I just love this simple cypher, it's so fun reading not-quite human-readable words and filling the gaps...
```
Ot wes thi bist uf tomis, ot wes thi wurst uf tomis, 
ot wes thi egi uf wosdum, ot wes thi egi uf fuuloshniss, 
ot wes thi ipuch uf biloif, ot wes thi ipuch uf oncridaloty, 
ot wes thi siesun uf loght, ot wes thi siesun uf derkniss, 
ot wes thi sprong uf hupi, ot wes thi wontir uf dispeor, 
wi hed ivirythong bifuri as, wi hed nuthong bifuri as, 
wi wiri ell guong dorict tu hievin, wi wiri ell guong dorict thi uthir wey – 
on shurt, thi piroud wes su fer loki thi prisint piroud, 
thet sumi uf ots nuosoist eathurotois onsostid un ots biong riciovid, 
fur guud ur fur ivol, on thi sapirletovi digrii uf cumperosun unly.
```
The rules are super-simple:
* Accept some text as input (ascii characters, upper/lower case letters and punctuation).
* For each vowel, rotate it to the next vowel, or back to the start.
	+ a => e
	+ e => i
	+ i => o
	+ o => u
	+ u => a
* Upper case vowels stay upper case, lower case vowels stay lower case.
* Output the text after these conversions.
* No need to support accents.
* The all other characters should remain unchanged.
* Try to do it in the smallest number of bytes.
* Any old language you like.
---
## Test Cases
```
It was the best of times, it was the worst of times,
it was the age of wisdom, it was the age of foolishness,
it was the epoch of belief, it was the epoch of incredulity,
it was the season of light, it was the season of darkness,
it was the spring of hope, it was the winter of despair,
we had everything before us, we had nothing before us,
we were all going direct to heaven, we were all going direct the other way –
in short, the period was so far like the present period,
that some of its noisiest authorities insisted on its being received,
for good or for evil, in the superlative degree of comparison only.
```
Out: 
```
Ot wes thi bist uf tomis, ot wes thi wurst uf tomis, 
ot wes thi egi uf wosdum, ot wes thi egi uf fuuloshniss, 
ot wes thi ipuch uf biloif, ot wes thi ipuch uf oncridaloty, 
ot wes thi siesun uf loght, ot wes thi siesun uf derkniss, 
ot wes thi sprong uf hupi, ot wes thi wontir uf dispeor, 
wi hed ivirythong bifuri as, wi hed nuthong bifuri as, 
wi wiri ell guong dorict tu hievin, wi wiri ell guong dorict thi uthir wey – 
on shurt, thi piroud wes su fer loki thi prisint piroud, 
thet sumi uf ots nuosoist eathurotois onsostid un ots biong riciovid, 
fur guud ur fur ivol, on thi sapirletovi digrii uf cumperosun unly.
```
In:
```
The quick brown fox jumps over the lazy dog.
```
Out:
```
Thi qaock bruwn fux jamps uvir thi lezy dug.
```
In:
```
Home is where the heart is.
```
Out:
```
Humi os whiri thi hiert os.
```
In:
```
Boaty McBoatface
```
Out:
```
Buety McBuetfeci
```
In:
```
AEIOUaeiou
```
Out:
```
EIOUAeioua
```
In:
```
Programming Puzzles And Code Golf
```
Out:
```
Prugremmong Pazzlis End Cudi Gulf
```
  
[Answer]
# MS-SQL, 51 Bytes
Works on SQL 2017 or above:
```
SELECT TRANSLATE(v,'AEIOUaeiou','EIOUAeioua')FROM t
```
The new function [`TRANSLATE`](https://docs.microsoft.com/en-us/sql/t-sql/functions/translate-transact-sql?view=sql-server-2017) performs individual character replacement, so is ideally suited for this challenge.
Input is via a pre-existing table **t** with varchar column **v**, [per our IO rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
In this case the table must be created using a *case-sensitive collation*, either by running on a case-sensitive server, or by using the `COLLATE` keyword (not counted toward character total):
```
CREATE TABLE t(v varchar(max) COLLATE Latin1_General_CS_AS)
```
**EDIT**: SSMS may cut off the lengthy quote above when returning the result in a "results to text" window, [this is a client setting, not a bug in my program](https://stackoverflow.com/questions/11897950/how-do-you-view-all-text-from-an-ntext-or-nvarcharmax-in-ssms).
To fix, go to `Tools > Options > Query Results > SQL Server > Results to Text` and increase the "Maximum number of characters displayed in each column."
[Answer]
# [Bash + coreutils](https://www.gnu.org/software/bash/), 24
```
tr aeiouAEIOU eiouaEIOUA
```
[Try it online!](https://tio.run/##dZFBUsMwDEX3nEIHYLhDFyy6YsUBlOYn1uBaGUtppjvuwA25SJFDhxI6rGzP@1/6kju2dLl4JYbovHvev7xSu3G77S6XvdPCRp5AHcxJB3I5wh5JbmTRukEPvxiPaGQR6/W4cV3JoJrFUoH9cWLSQ2qKDlkwbLw/TMqhop@z@HnrNrBpaZIsY/KN@8Z6rm/3nW2qUsbGk07YjirFUVcrbGKp4VxAiXvCCfXsqTk7DFpBc9S9wqJ3pPkWxINzplEb7aXi4ORKCXxCWe3/aCJM1IwsC5/p8/0jJihkSWvM2uCEKtqvwU1p4BqLeMM3qjAUv0oiiSf2UB3XDxG3iCsm7b959igpHo/YtYk5eordNVGHlifSQE5oZWK0CBlN42x3nCTH9sr3Uudol9lDG7sbK9ZmBz1OXGX9jpLPT18 "Bash – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 52 bytes
```
(a:b)!c|a/=c=b!c|1>0=b!!0
a!b=b
map("aeiouaAEIOUA"!)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/XyPRKklTMbkmUd822TYJyDC0MwDSigZciYpJtklc6ba5iQUaSompmfmliY6unv6hjkqKmv9zEzPzbAuKMvNKVNKVPEsUyhOLFUoyUhWSUotLFPLTFEoyc1OLlf4DAA "Haskell – Try It Online")
*Lynn saved me two bytes by pointing out that `!!0` is shorter than `head`.*
## Explanation
If you have never coded in Haskell this will probably look like a pile of jibberish. So first let's ungolf it and then break it down:
```
(a:b)!c
 |   a/=c   = b!c
 |otherwise = b!!0
a!b=b
map("aeiouaAEIOUA"!)
```
First we have a function `!`, which takes a string `s` and a character `c`. Our first pattern match catches accepts input if the string is non-empty. If the string is non-empty we compare its first character to `c`. If it's first character is not equal to `c` we toss it and call `!` again with the remainder of the string and `c`. If it is equal we return the second character in the string.
Our next pattern match catches the string in all other cases, that is if the string is empty. In this case we just return `c`.
All in all this function takes a character `c` and a string `s` and returns the character after the first occurrence of `c` in `s`. If we pass this with `aeiouaAEIOUA` it will perform our cipher on a single character. To make our whole function we ought to map this across the string.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
öΦΣòC└∞
```
[Run and debug it](http://stax.tomtheisen.com/#p=94e8e49543c0ec&i=Programming+Puzzles+And+Code+Golf)
[Try it online!](https://tio.run/##ATgAx/9zdGF4///Dts6mzqPDskPilJTiiJ7//1Byb2dyYW1taW5nIFB1enpsZXMgQW5kIENvZGUgR29sZg "Stax – Try It Online")
**Explanation** (unpacked)
```
Vv:tVV:t
Vv:t           #Push aeiou and ring translate it to input
    VV:t       #Push AEIOU and ring translate it to input
```
Might be able to save more, will keep trying.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~10~~ ~~9~~ 8 bytes
```
T`uo`vVA
```
[Try it online!](https://tio.run/##HYnBDoIwEAXv/Yr3BSR@AhqjHowcxDMrLFClXV1aEH4e0dNMZpSD9bRZlmsRpRhu6Wot4x1t@cRdZfSo5YNHdK8eMrAirLujeUIlTWKO4hi2x9iy8v@1TBrWlJitUJhwLn@sqWST7k@XnNhKNJlKo@Sc9Q2yOM8d90h9hZ1UjIN09Rc "Retina – Try It Online")
Saved 1 byte thanks to Neil! And another byte thanks to Martin!
The new version of retina has vowel classes, which makes the result a bit shorter. The transliteration also makes use of the "other" class. So the `to` class looks like "aeiouAEIOUA" while the `from` class looks like "uaeiouAEIOUA"
This doesn't cause any problems since the second `u` mapping to `A` will never be done since `u` was already mapped to `a`.
[Answer]
# Perl 5 + -p, ~~24~~ 23 bytes
```
y;AEIOUaeiou;EIOUAeioua
```
[Try it online](https://tio.run/##dZExUsMwEEX7nEIHCHRUVCkoUlFxACX@tnaiaDXatT3uuAM35CCYlZMhMQyV1/P@1359ZZT4NM/T8@5l//rmQdw/12lXJz/Pe3WjF6cB7gBRx61TOkO2jm5k5HKPNnfId6hgJGn4vDJdScscSUKCrI3IfAxVcEAktCvrD6N0LGj6SDqtzAIvnKoiUhd0Zb6xxpfTn72SC6Wu4sAZ62tSUpTFCcmeynYzwgXfOAwok4ZqPKDlAtdbQ1eY@DepthE2@xhdxxU2VHBUp@wC/IC0uP/RWBQ70pKMfnKf7x8bSk4CF7tnZRmFuFlSC7vWFyvhhAsqECS9SrYbDV5NdF5eglQsKwnVd/a92omk9mMtC4micVZbFR1Q01gW0AA7xa5lCW2lfeuMgaIVly599rYsejWp1dYVLLuOfM6@0PIQKU6PX5yVOMn8kL8B)
-1 byte thanks to @DomHastings
[Answer]
# C, ~~85~~ ~~76~~ ~~67~~ ~~65~~ 64 bytes
```
f(char*c){for(;*c;)putchar(1[index("AEIOUAaeioua",*c++)?:c-2]);}
```
Port of Kevin Cruijssen's Java [answer](https://codegolf.stackexchange.com/a/163249/79343). Try it online [here](https://tio.run/##TcmxDoIwEADQWb7i0umuwKCjHQyDA5OTk3GoZysdoKQtwYTw7TVMuL7H9Yc5Z4vc6SCZFusDKsmKxilthseHG97mi6K5trd7o43zkxaV5LKky5nr05PUmnvtBiRYioNF0SaYdYTUGXiZmMBbSK43sQK3z@zDfwlSxZp/).
Thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for golfing 9 bytes, to [Christoph](https://codegolf.stackexchange.com/users/29637/christoph) for golfing 11 bytes and to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) for golfing 1 byte.
Ungolfed version:
```
f(char* c) { // function taking a char array as parameter and implicitly returning an unused int
    for(; *c ;) // loop over the input
        putchar(1 [index("AEIOUAaeioua", * c++) ?: c-2]); // find the first pointer to the current char in the vowels string, NULL if not present; if it's not NULL, print the next vowel, otherwise just print the char
}
```
[Answer]
# Python 3, ~~62~~ 59 bytes
```
lambda x:x.translate(dict(zip(b'aeiouAEIOU','eiouaEIOUA')))
```
Make a translation table (dictionary) ~~with `str`'s static `str.maketrans` method~~. Translate relevant characters to their destination character.
EDIT: Saved 3 bytes by using the `dict` constructor to make the translation table instead of the `str#maketrans` method
[Answer]
# [R](https://www.r-project.org/), 43 bytes
```
chartr("AEIOUaeiou","EIOUAeioua",scan(,""))
```
[Try it online!](https://tio.run/##dZFBbtwwDEX3cwrBqwQweocsusiqqx6AY39bRDSiQdJjzK536A17kSnlDJq4RVem8f4Xv770fh8yqetT9/L19dt3Asva9V2bX9pMXW8D1ae@656f792rp40seUY6wzzJlJwvsD7xB9lEP6PTJ0QzGtjYRrkcTA8yiRS2XGFHIxYZchOcURjTwfqHcR0U41rYbwezgUxqUxSesx/MH2wkfftnry3KdW44y4LjNbk6dHfCFmLtTxtSpjHhCr15bsYzJlGkNRp6wCp/k2bbEDOVkmZpcGTF4MklZdAVdXf/RxNR4shIstEt/frx88Q1WRaNeza2QFnGPbVJmkijhDe8I4Wh@kPSnzyTh@iyvwS7RVY2bu9Mq8eJ7PETLRubY0xRWxOd0dJEFvAVcUpcKxLGyvi2GVcuUVx973ONZYU8pFHbrNh3DXJZSHl/iFpuX7r7bw "R – Try It Online")
Here's my solution wrapped in a `cat` to get it to print out more nicely: [Try it online!](https://tio.run/##dZExbsMwDEX3nELwlABG75ChQ6ZOPQBj0xYRRTRI2ka23qE37EVSygmauEUn03j/i19fcr02YNsmgphsq/3r4e0dkHis6qrM@zJDVWsDeVtX1W63u1YHCzNosIjhiGqBu2B0Rq0DPcjM8ow2Twh6LGAmbfm8Mt1Jx5xIY0ZdG3HgJhbBERNht7L@MMqNYDsmssvKrAjKuSgS9dFW5gdrQU5/9uoglPuCIw@4viZlQ1mcqAOQ1JsZQ4Q24IRysViMR@xYMIze0B1m/k2KbUafIaXQc4EtCTYWjENEmDAv7n80HsWP9CQzXMLXx@eGctDI4vcsbEAhbpfUyqED8RJOeEOCitnuknpjEcxF5@UlyNSzklJ5ZxjNTyTzH29ZSQ3b4LUV0RFLGs@CNKGf4tfyhL7Sv2XGiZIXl299jr4sgbnUa@sFl10NnwcQWh4ip8tLdf0G)
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-p`, 31 bytes
```
$_.tr!"AEIOUaeiou","EIOUAeioua"
```
[Try it online!](https://tio.run/##dZExUuwwEETzPYX@FuH@vQMBARERMSWv29YUWo1rZrwuZ/8O/4YcBDMyW4ChiDyu161ptWRs5mW5eTqa/Nnf3t0/PEYQj/vDvs63dY77Zbm3MEUNlhAaqAXugtEZegj0SSaWr2j3BcUeFUykLZ83pivpmDNpKtCtEQOfUhU0yIRuY/1gVE6Cdsxk88asiMqlKjL1yTbmT9ZGef6xVweh0leceMD2mlQMsjqhQyQ57CaEFNuAC2S2VI0NOhaE0Ru6wsLfSbVN8DnmHHqusCXByYJxSIgXlNX9i8aj@JGeZIpzePn3f0claGLxe1Y2QIjbNbVy6KJ4Cc94RwJFsavksLMUzUXn9SXI1LOSUn3nOJqfSOY/3rKSGtrgtVVRg5rGs4Au8FP8Wp7QV/q3zrhQ9uLKe5@jL8vRXOq19YJ114nPQxRaH6Lk@fjKgxEXXf4Obw "Ruby – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
Øcs5ṙ€-Ẏ,Ʋy
```
[Try it online!](https://tio.run/##dZExUsMwEEV7n0IHCHQcgmPI9re1RJY82rU97hgOQEMDd6Cig5YZ7pFcJKycDIlhqCzr/a/9@rqD9/Ph8Plc8c3u/WX/8Hq1@3jcfL3p5uFWzGTZiIMpwWJiY4Q68MbQmUwxXaLiAtkWGUzEdexWphNpYvTELoDXRvSxcllQwhOalfWHUagS6sGTzCszw3IMWeGpdbIyn1lt0/bPXO4ThTZjF3usr0lBkBYnuLeUNsUE42xtMCLN4rKxRBMTzKANnWCIv0m2TdC19d60McOaEioxEo2DHREW9z8ajaJHapLJzmZ//1RQMOxi0ntm1iNRrJfUHE1jk5awxRElMIKcJJtCnBUVdctLkLBmJab8znYQPZFEf7RlJhbURmvLohI5jWYBjdBT9FqaUEfqN68xktfiwrHPQYd5KyrV2tqEZVYVu94mWh4i@Pn6Gw "Jelly – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~79~~ ~~68~~ 67 bytes
-1 byte thanks to @ArnoldPalmer
```
V='uaeiouAEIOUA'
print''.join((V[1:]+c)[V.find(c)]for c in input())
```
[Try it online!](https://tio.run/##dVPbbtNAEH3PV4zy4gSqSEXiBakPaQltgJK0kHCp@rCxx/ZQe8faXcekT/wDf8iPhJltRJsIJEvr9TlnbmfcbELJ9sU25QzhBPr9/nZ5krQGidvxZDpbjJNe48iGJBl9Z7KDwfLm@NXt83R4sxzlZLNBOrzN2UEKZOVp2jAYDrcSp9fDH5hCDPwMjl9uk08XE7haTM/ewen17PMHeDP7Am8Xl/OPMFtOrkHh9@NvX@H17HyU9JK548KZuiZbwLy9v6/Qw9hmcKYRz7nKhXPBNQJ56Ep0CKFEKNG4IJ80wimbsIHLVM/cpCifYk@xO7lMA3TGR9kKfQDOIVCN/gjoEenYPYVE9gQ0BSrUkc@43pPtkJy5Il9a9IdSbDgtlbLCijDfE//FyKYOs7aisDmQezSerXIqKsqwJ3/EMuPu/pHbq6WFEkpucL9d8Rpd1KJvDDmVdjJXkwGu0cm@qHSFYjpCK7PagZYPkQdhp86YqoKCFc7IYRogsDq1Rhv1/@FIORJUqunMBn7//KVNWPAlO@lX0QYdcRZr9wy5cTKMu4c9aBx6tGFH0VpCaYLQ6ugLBS8Vkyf13bTyEzgKcpGJe/IBM5ABKmmFWpHUg7TGGEe3vWBJK6e@45qqI93@ONlWElYmCFkGWDiM2VKuG@MommKrzSj5Aw "Python 2 – Try It Online")
[Answer]
# JavaScript (ES6), 60 bytes
```
s=>s.replace(/./g,c=>(S='aeiouaAEIOUA'+c+c)[S.indexOf(c)+1])
```
[Try it online!](https://tio.run/##dZI9cttADIV7nwKdyJFDTw4gz7hI4cqFJ1WSYrUEubBXC84CJKMud8gNcxEFS2tCKWNX/HkPHx/e8sVNTnymQT8lbvHU7U6yu5cm4xCdx@quuetv/e6@et5tHBKP7uHL49PXh83Wb3397bmh1OLPp67y9fbzj/rkOQlHbCL3VVfdAGweFWYnoAFhj6LAHSgdUG6BVmXmfCl9TxvYluELi@uxGGaSlg9Xw2elY44kIaG8D8CBfSjGPUbC7grxT6PkM7ZjJD2@CxF0wqk4I/VBryCr1rr8@mEOGTKlvtgCD3hdAyXFvBBQBkd5BcwIwbWAE@ajhgLYY8cZYbQmz2Li/5XL8RntnYsRei6mljJ6BWUI6CZMC@UDj0UztCWb3RH@/Pq9rpVAAmfroXgGzMTtso0wdC5bSa/4JmUUTHq2rLk0ODXzYTlBUrEdSKj8J25UI5Pag52KkCi2YPUW0x5LOsuGNOEFzda25BbBruUeJ4pWcHrrfbSPR6c2YvX2GZdvej4MLtNycCkem81NXZ/@Ag "JavaScript (Node.js) – Try It Online")
[Answer]
# Pyth, 17 bytes
```
em=.rQdrB"aeiou"1
```
[Try it here](http://pyth.herokuapp.com/?code=em%3D.rQdrB%22aeiou%221&input=%22It%20was%20the%20best%20of%20times%2C%20it%20was%20the%20worst%20of%20times%2C%22&debug=0)
```
em=.rQdrB"aeiou"1
 m                  For each string...
       rB"aeiou"1   ... in ['aeiou', 'AEIOU']...
  =.rQd             ... cyclically rotate the characters in the input.
e                   Take the last.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) 2.0, ~~25~~ 21 bytes
I had fun golfing this one with Shaggy.
```
r\v@=`aeia`pu)g1+UbX
```
[Run it here.](https://ethproductions.github.io/japt/?v=2.0a0&code=clx2QD1gYWVpjGFgcHUpZzErVWJY&input=IlRoZSBxdWljayBicm93biBmb3gganVtcHMgb3ZlciB0aGUgbGF6eSBkb2cuIg==)
[Answer]
# Java 10, ~~97~~ 87 bytes
```
s->{for(var c:s){var t="AEIOUAaeioua"+c+c;System.out.print(t.charAt(t.indexOf(c)+1));}}
```
-10 bytes after being inspired by [*@Arnauld*'s JavaScript answer (his 60-bytes version)](https://codegolf.stackexchange.com/a/163172/52210).
[Try it online.](https://tio.run/##hVRNb9QwEL33V4z2lKh0Ja6sirRUCHroh1Q4AQevM0mm63iC7SRNq5X4D/xD/sh27F3YZhFCShTbb97M87Mn96pXZ/fFequN8h6uFNmnEwCyAV2pNMJ1nAL0TAXoTNfKffkGPl/I6kZeeXxQgTRcg4Vz2Pqzt08lu6xXDvQbnz/FQTifLd9f3nxeKiTu1OxUn@rF3egDNnPuwrx1UjAL85h@GQdkC3y4KTOdn77O88Vms13sirXdykixfc2kqhHN2V2QFJVIU/lOcEAfstllgEF5CDXCShaASwjUoH8FdEAGdi@hr/YFpiqMyEC@4GbC2iMlsyFfW/RHTGxZ1zFihYawnHD/YGS1w6IzFMYp26PybGOIoaoOE/YBK5Rb/13ZRzuriNfc4nSr6WATFX2ryAlzQKhVAdijG0MdmSuUE0ToxKY9aPkYSbwBZaKMgYojWpBDHSAw1Kh6tIn@jxgRIzlFy6BG@PXjp@zAgq/ZyV4j2KIjLpJwz1DKJTK0xh3k0KMN@xBREmoVJKpJB0LBi1zyFM9bdUFSUpCJeO1JblwB4l0MWmHUI2qQeoxpZGsiUorKN46xJyPu2Z2pnZQzcut6FO8qh6mY5qZVjtJxWDPOZ6kxft@@T8L73pFew8rxYCXpA9x3TeuBxeyU1qjHEQqujpgf42bIw1BH92KgOOqCLB0FvmMVRrjS8Rv7dYqmpks9N12/dVw51TTRgNvu8dGIPUtbwAUXCB/YlLN9gx/aO7VaYu9aTf4Bu0azc535eeCL2LvOqTHL97WOG9zY7D/I5mSzfQY)
**Explanation:**
```
s->{                         // Method with character-array parameter and no return-type
  for(var c:s){              //  Loop over the input characters
    var t="AEIOUAaeioua"     //  Temp-String containing the order of vowels 
                             //  (including additional 'A' and 'a'),
          +c+c;              //  appended with two times the current character
    System.out.print(        //  Print:
      t.charAt(              //   The character in String `t` at index:
         t.indexOf(c)+1));}} //    The (first) index of the current character in `t` + 1
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~14~~ ~~13~~ 11 bytes
```
žMDÀ‡žMuDÀ‡
```
[Try it online!](https://tio.run/##dZJBTsMwEEX3OYXVdYVgwQ3YsOAQTvITj@p6Is@kUXa9AyfgImwQF@lFyjitKAGx6lTvf8/3d@4fff2A8/nz/eXp43g6vtkwXqbzebPZPKubvDgNcDVEHXdOaQ/ZOrqRifNPVP1AvkcBE0nL@5XpSjrmSBISZG3EwE0oghqR0K2s34xSk9GOkXRemQVeOBVFpD7oynxjrc@7P3tlyJT6ggMPWF@TkiIvTsjgKW@rCS741uGAPGsoxhodZ7jRGrrCxL9JsU2w2cfoei6wpYxGnbIL8Aekxf2PxqLYkZZk8rM7HV8rSk4CZ7tnYQMycbukFnadz1bCDheUIUh6lWwrDV5NtF9eglQsKwmVd/aj2omk9sdaFhJF66y2IqpR0lgW0AF2il3LEtpK@y0zDhStuHTpc7Rl0atJrbY@Y9nV8H7wmZaHSHG@sy/tCw "05AB1E – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 20 bytes
```
T`_o`A\EI\OUAaei\oua
```
[Try it online!](https://tio.run/##dVJBbtwwDLzrFXzAon/YFkGzhyI5JLcFGtmiLXZl0aXodbyn/qE/7EdSylk0cYueJGtmyOHQgkrZv7w8PH3lp/3x5nC8e9x7pCNP9npQmH0BjQgNFgXuQGnAsgN6Q2aW95B7B/keKzBTCTxsRFekY05UYsayFeLIbayEBhNht5H@wSi3gmFKpMtGXNAXzpWRqI@6Eb9hwcvpn75lFMp9hSOPuB2TsqKsSiyjJ9m5GSH6AHhGWTRWYYMdC8JkCV3BzH8jVTaj3X1K0HMFAwm2CsoQ0Z8xr@r/cMyKlTQns1/g14@fjjKUyGJzVmxEIQ6r68LQebEQTvgKCRbMeqXsnEavRhrWTZAW80qF6p79pFaR1D4s5UJFMYDFVkkNVjfmBemMVsXGMofW0s56xzMlCy6/5jlZs@TVqBZbL7j2ankYvdC6iJyWD849GPf7RO0JGuE5W6Fn@DYNYwG2cNdSyV8WCNwb@7Z6pgJzrBFV0GITtScDP7LXBb609ex8i87tbw53j/ZP8@TcvXAvfhjqDPfT5ZJswn0O8IkDwmdO3W8 "Retina 0.8.2 – Try It Online") Link includes test cases.
[Answer]
# APL+WIN, 55 bytes
Prompts for input string:
```
i←(10≥n←'AEIOUaeiou'⍳s)/⍳⍴s←⎕⋄s[i]←'EIOUAeioua'[n~11]⋄s
```
[Answer]
# Mumps, 38 bytes
```
R T W $TR(T,"AEIOUaeiou","EIOUAeioua")
```
Mumps doesn't normally add a carriage return, as I didn't see a requirement to separate input from output it does look a bit weird on first run. For example, the output for the last test case looks like this:
```
Programming Puzzles And Code GolfPrugremmong Pazzlis End Cudi Gulf
```
If you did want to add a carriage return, add two bytes thusly:
```
R T W !,$TR(T,"AEIOUaeiou","EIOUAeioua")
```
[Answer]
# Vim + [tpope/vim-abolish](https://github.com/tpope/vim-abolish), 30 bytes
```
:%S/{a,e,i,o,u}/{e,i,o,u,a}/g<cr>
```
Alternate solution, also 30 bytes:
```
Oe,i,o,u<esc>|D:%s/{a,<C-r>"}/{<C-r>",a}/g
```
According to [meta](https://codegolf.meta.stackexchange.com/a/11751/31716), vim answers can use plugins with no byte penalty. This is not a vim answer, but a *vim + abolish* answer.
---
Abolish is an extremely useful plugin. [This section of the README](https://github.com/tpope/vim-abolish#substitution) nicely describes how this command (the `Subvert` command) works.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 29 19 bytes
```
q"aeioua"_eu+_1m<er
```
[Try it online!](https://tio.run/##dZFBTsMwEEX3PYXVLRUSey7AKapp8hMPdTzBM2nUHXfghlykjNOKEhCrOHr/e/58N680XC5vWwLLRNs9pof90/CMcrlsXyzMpMEiwgFqQbpgPEB3ge9klvITbX4g6lHBzNrKsDLdSCeSWGOGro0YpYlVcEBidCvrN@PcFLRTYjuvzApSyVWRuI@2Mt9ZS@X4Z66OhXNfcZQR6zU5G8rihI7EZbeZESK1ASeUs8VqPKCTgjB5QzeY5Tepthl@ppRCLxW2XNBYMAkRdEJe3P9oPIpf6UlmOofP948N56BRiu9Z2YjC0i6pVUJHxUs44ooKFNlukt3GIpmLhuUl2NSzsnJ9Z5rMb2TzH29ZWQ1t8Nqq6ICaxrOAT/BbfC1P6CP9W884cfLi8rXPyYclMpd6bX3BMquRYaTCy0PkdH7cfgE "CJam – Try It Online")
-10 bytes thanks to @Peter Taylor
Explanation:
```
q                       # take all input
 "aeioua"               # push vowel pairs
         _eu            # duplicate, uppercase
            +_          # concatenate, duplicate again
              1m<       # rotate left by 1
                 er     # transliterate
```
[Answer]
# [AutoHotkey](https://autohotkey.com/docs/Hotstrings.htm), 24 bytes
AuotHotkey automatically replaces letters in a case sensitive manner.
```
a::e
e::i
i::o
o::u
u::a
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 9 bytes
```
k∨:½ƛǓ;∑Ŀ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=k%E2%88%A8%3A%C2%BD%C6%9B%C7%93%3B%E2%88%91%C4%BF&inputs=Programming%20Puzzles%20And%20Code%20Golf&header=&footer=)
Basic transliteration.
[Answer]
# [Elm](http://elm-lang.org/), ~~127~~ ~~123~~ ~~121~~ ~~112~~ 103 bytes
*9 bytes saved by [Hydrazer](https://codegolf.stackexchange.com/users/104014/)*
```
f a b=case a of
 c::d::e->if c==b then d else f(d::e)b
 _->b
String.map(String.toList"aeiouaAEIOUA"|>f)
```
## Explanation
This Elm answer is a port of [my Haskell answer](https://codegolf.stackexchange.com/a/163155/56656). I am still learning Elm so there might be a good deal of golfing that can be done. There are a couple of differences here between Elm and Haskell. Elm does not allow multiple declarations of a function so we have to use `case` instead. Elm is also rather fussy about strings. They are not list of characters and thus have to be treated differently then lists. In fact in order to do any useful of manipulations on strings we pretty much have to just convert them to lists. Aside from that there are a couple of small differences `::` is the list cons operator and `(|>)=flip($)`.
You can test the code [here](http://elm-lang.org/try), with the following wrapper:
```
import Html exposing (text)
f a b=case a of
 c::d::e->if c==b then d else f(d::e)b
 _->b
g=String.map(String.toList"aeiouaAEIOUA"|>f)
main=g"It was a dark and stormy night"|>text
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
kv*kV*
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrdiprVioiLCIiLCJUaGlzIGlzIHRoZSBmaXJzdCB0ZXN0IGNhc2UiXQ==)
```
  *    # Ring translate by
kv     # Lowercase vowels
     * # Ring translate by
   kV  # Uppercase vowels
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 25 bytes
```
{y^'x[<x]x?y}"UAEIOuaeio"
```
[Try it online!](https://ngn.codeberg.page/k#eJx1VUGO20YQvO8rBkKA2IDh3FcBgnVg2D4E3kN8WmzgIdkUOxqy6ZlpUVzDQf6QH+YlqR4qWsrY1YUiq6qnp7o4bK+/zn/8eLz7+Xh//GX+tvl08/bDR/XEsrm6ytdff7ib/4rXrTtuP8t+++Jz6zlsj9t5G1/ef7vKd69+erH5kN3kk8sduYpSdtK6zD2lV44fkUniGtpcOfttVgy/I8MnTo30F9oT0ooETt1A6Uk9jVJ3xqsoMLUXFc4YD3WkRgPn+akaiXySwYiBd12+qPGINT7un+sijZGHnbE6GenSAh4yxVKA0ug5nvUTuc43jg4U59yZvqJWIjmFiSdwkO+RlXoiPPIhuJ0Yp+FIdXZZXEf+QEMp8gwHjaEy+pr87P79+5/zngaXOonwwCgjRZambCWJa32EQXtaoEiJhnyinLvKnc/g9mV0nBM2wIktH14zCnPGDeaROGVqHJw1UkXWGzojPtBjMWwZbaMBXO0/HTjA22GxXLF08BkKOLuLVJaspR995DKyIcyvNy9Ry+L6ERMhmwi7Cms7RSalZzgtj8ikcQ3938eKQTs2fJLUaH+hPSGtahDEldOTeh4VkQSv4iDcXlQ4Y4K4cuODrOK64pmfOhgxSInrk1hDiOszXSCuAsPB6nTkSwtkyBxLAU4jySqujFw1jg9scTV9xa1Gdt7iuoCDfo+s1BPjEVkU1TgN0mBRVNcxJjuUIs9w0Bgqo6+JLuIqFldd4spu5CjalK0kdS3SHWTPC4RMsMW1UFZxJcRV+zI6sbiqJLF8kM8oLBk3mEeSlLlxcNZIFVtv6IzlwKu4KuKqaABX+88HQVxlWCz3WDpQhgLO7iKXJWvtkWIpI1vieo/jdfM78v1Fud67Kso0IPxH9yeoaAWHRYl/8A8z7Nm9ttUhYPfFSxGoCRQCbwLFuEoDgUygEJQl3ts7ir1NnR0QVhGHRsx4tFR8b6aI4TYRK4ApAZd0KvBGfJ7db7VdW19TUb1RWh7i2lLNC9W+Lp/s66KFZHc3ducX+DbKLvq+tzPgVh8eAuZ3MzTuV2nIvZPQFtVtVLzkfW/W33qw0PxbY2nD7p2Cdf8fpmlK3Q==)
[Answer]
## PHP, 90 Bytes
[Try it online](https://tio.run/##RcixCsIwEIDhVzmKQw76Bi1IEREnu3QuMU3aQJoLl2Sw4rPHLOLyw/@FLZT@HGpN9ipZ8mDEKeJbq40gJk5ct5XM8jUr2p/Wa1F5jsHZJKY8yKu@2wdh@9efTRkRu08xohmZVpb7bv0KYz4OpyMMfoELLRpu5EyDXfkC)
**Code**
```
function f($s){echo strtr($s,array_combine(str_split(UuAaEeIiOo),str_split(AaEeIiOoUu)));}
```
**Explanation**
```
function f($s){
 echo strtr(
       $s,                          #The string to operate
       array_combine(               #combining arrays
            str_split(UuAaEeIiOo),  #splitting this strings
            str_split(AaEeIiOoUu))
              # With array combine php creates an array like
              # ["U"=>"A", "a"=>"e"....and so on]
              # strtr can replace strings in a string, using an array with 
              # the values to replace and with what replace each value.
 );
}
```
**75 Bytes if ran with `php -r` using `$argv`**
```
<?=strtr($argv,array_combine(str_split(UuAaEeIiOo),str_split(AaEeIiOoUu)));
```
[Answer]
# [J](http://jsoftware.com/), 33 bytes
```
rplc'aeiou',&((;"0)1&|.)'AEIOU'"1
```
[Try it online!](https://tio.run/##TcvBDsFAFIXhvac46cLVpJp2SywQkiZEIjzAdMxQ1K2Zqap49yoLLE7O4s93bLyQNEYDEAJEGLTrh5iuF/PGFGdJQmVcUtDt9YZe5MfdZ@jTeJastuTFjd9BR8kDQ4MSh0pYuINCqqwDa7gsVzZA9isVm/9EX71p47XM5Amp4eoCzXccy7yw4JsyH3sWjxo73oc/NWHhaizl@7WQipoX "J – Try It Online")
[Answer]
# [str](https://github.com/ConorOBrien-Foxx/str), 18 bytes
```
[aeiouaAEIOUA]#D#U
```
[Try it online!](https://tio.run/##dZExbsMwDEV3n0JA1qB3CNAOmTplKjoo8bdFRBYNkY7hrXfoDXsRl3KCJm7RyTLe/@Lnl2ie5zcP4sHvXvavh9375nlzmOe9utGL0wB3hKjjxil1kK2jOxk5P6LqAfkWBYwkNXcr0400zJEkJMjaiJ5PoQiOiIRmZf1hlE4Z9RBJp5VZ4IVTUURqg67Md1b7fP4zV/pMqS04cI/1mpQUeXFCek95W41wwdcOF@RJQzEe0XCGG6yhG0z8mxTbCDv7GF3LBdaUcVKn7AL8BWlx/6OxKHalJRn95L4@PitKTgJn27OwHpm4XlILu8ZnK@GMK8oQJL1JtpUGrybqlpcgFctKQuWd/aB2I6n9WMtCoqid1VZER5Q0lgV0gd1ia1lCG2nfcsaFohWXrn0ONix6NanV1mYss07c9T7T8hApTk/f "str – Try It Online")
## Explanation
```
                       implicit: over each character of the input:
[aeiouaAEIOUA]#D#U
[            ]         push this string
              #D       set this to the operation domain
                #U     set the charcter to the next character in the domain
```
]