Eu mantenho este texto estranho, onde os vewols parecem ser ratodod:

Eu sou um texto mal escrito. Um cara lunático brincava com a ordem das vogais. Por favor, me conserte!

Então, eu precisaria de um pragrom que possa ratificar os vewols (e a letra 'y' como parece) de volta, para que o texto seja rastreável novamente.

Ouy pode escolher a lungaega de ouyr chieco privedod ouy meka um cempleto pragrom (então não apenas um finctoun). O yntre pode ser um campo sem caroço, um feli de texto ou o cammond leni. O uutpot mya olsa vyra como ouy leki.

É claro que eu vou fazer uma pesquisa sobre textos ruins. Não existe vulea em um pragrom que os textos mekas não possam conter. Mas eles podem escrever cemitérios e substantivos em textos ratodod, se quiserem.

Esclarecimentos

• Seu programa é necessário apenas para lidar com texto ASCII.
• Para os fins desta pergunta, os seguintes caracteres são vogais: aeiouy
• As posições das vogais dentro de cada palavra devem ser rotacionadas. Há alguma flexibilidade para decidir o que qualifica como uma palavra: o requisito mínimo é que dois caracteres separados por um espaço estejam em palavras diferentes e que dois caracteres alfabéticos ( a-zA-Z) separados apenas por caracteres alfabéticos estejam na mesma palavra.
• A direção de rotação desejada deve ser inferida a partir dos casos de teste abaixo.

Casos de teste

Entrada: I'm a badly written text. Some lunatic guy played with the order of vowels. Please fix me !
Saída:I'm a bydla wrettin text. Semo lanituc gyu plyead with the erdor of vewols. Plaese fix me !

Entrada: AeiOuy
Saída:EioUya

Entrada: Hyphenated-word
Saída: Hephanetyd-wordouHephanetod-wyrd

GolfScript, 68 67 57 caracteres

" "/{..+{95&"AEIOUY"?)}:C,1>\{.C!!{96&\(31&@|}*}%\;}%" "*

A entrada deve ser fornecida no STDIN. Exemplo ( online ):

> You!!! I'm a badly written text. Some lunatic guy played with the order of vowels. Please fix me !
Ouy!!! I'm a bydla wrettin text. Semo lanituc gyu plyead with the erdor of vewols. Plaese fix me !

Ruby, 91 90 caracteres

$><<gets.gsub(/\S+/){|x|x.gsub(r=/[aeiouy]/i){|y|z=$'[r]||x[r];y>?Z?z.downcase: z.upcase}}

Coffeescript, 148 caracteres

alert prompt().replace /\S+/g,(x)->x.replace r=/[aeiouy](?=(.*))/gi,(y,z)->((t=z.match r)&&t[0]||x.match(r)[0])[['toLow','toUpp'][y>'Z']+'erCase']()

Não há nada a dizer, exceto que "holf-cerract" é uma palavra, e não meu sulitoon.

Teste:

> To test this program, simply enter a long sentence that appears half-broken
  To test this pragrom, sympli enter a long sentence that eppaars holf-brekan

> No MaTtEr HoW mUcH cAsE yOu uSe, It WoRkS
  No MeTtAr HoW mUcH cEsA oUy eSu, It WoRkS

Haskell, 159 caracteres

Não acabou tão curto quanto eu esperava, mas decidi publicá-lo de qualquer maneira:

import Data.Char
f s=let(v,t)=foldr g(v,[])s in t
g x(v,t)=last$(v,x:t):[(x,c v:t)|c<-[toUpper,toLower],x`elem`map c"AEIOUY"]
main=interact$unwords.map f.words

Versão não destruída:

import Data.Char

rotateVowels :: String -> String
rotateVowels word = result
  where (vowel, result) = foldr step (vowel, []) word
        step ch (vowel, rest)
          | ch `elem` "AEIOUY" = (ch, toUpper vowel : rest)
          | ch `elem` "aeiouy" = (ch, toLower vowel : rest)
          | otherwise          = (vowel, ch : rest)

main = interact $ unwords . map rotateVowels . words

Este é um bom exemplo de como a avaliação lenta pode fazer truques interessantes. Em rotateVowels, cada vez que uma nova vogal é encontrada, ela é passada para a esquerda, enquanto a substitui pela que vem da direita. Essa parte da saída da dobra é realimentada como entrada, de modo que a vogal mais à esquerda se torne a substituta da mais à direita.

(vowel, result) = foldr step (vowel, []) word
 ^^^^^                        ^^^^^
 this part of the output      is part of the input

Python 2 , 172 bytes

for w in input().split():p=[];q=list(w);z=filter(lambda c:c in'aeiouyAEIOUY',q);x=z[1:]+z[:1];print''.join(y in z and[str.upper,str.lower][y>'Z'](x.pop(0))or y for y in q),

Experimente online!