Scrivi una funzione che accetta una stringa di lettere e spazi (non è necessario gestire non lettere) ed esegue l'algoritmo di traduzione VOCALE ANNOUNCER come segue:

• Innanzitutto, tutto in maiuscolo.
• Per ogni parola,
  • Allunga ogni gruppo di consonanti triplicando ogni lettera; tranne, se la parola inizia con un gruppo di consonanti, non allungare quel gruppo. Ad esempio, otherdovrebbe diventare OTTTHHHEEERRRma motherdovrebbe diventare MOTTTHHHEEERRR.
  • Allunga la vocale finale triplicandola.
• In entrambi i casi di allungamento , se stai triplicando una lettera, prima mescola con lettere duplicate su entrambi i lati. Ad esempio, hilldovrebbe diventare HIIILLLe bookkeeperdovrebbe diventare BOOKKKEEPPPEEERRR.
• Ai fini di questa sfida, yconta come consonante.
• Chiarimento / semplificazione: è possibile supporre che ogni coppia di parole sia separata da un singolo spazio e che l'input non contenga spazi consecutivi e che l'input non sia la stringa vuota.
• Vince il codice più corto!

Vettori di prova:

> sunday sunday
SUNNNDDDAAAYYY SUNNNDDDAAAYYY
> mia hamm
MIAAA HAAAMMM
> chester alan arthur
CHESSSTTTEEERRR ALLLAAANNN ARRRTTTHHHUUURRR
> attention please
ATTTENNNTTTIOOONNN PLEASSSEEE
> supercalifragilisticexpialidocious
SUPPPERRRCCCALLLIFFFRRRAGGGILLLISSSTTTICCCEXXXPPPIALLLIDDDOCCCIOUUUSSS
> moo
MOOO
> Aachen
AACCCHHHEEENNN
> Oooh
OOOHHH
> grifffest
GRIFFFEEESSSTTT
> k
K
> aaaabbbbc
AAAABBBBCCC

Ecco un'implementazione di riferimento che vorrei passare a una risposta, tranne che da stamattina la domanda è stata chiusa. : P

import itertools,re
def j(s):return re.match('^[AEIOU]+$',s)
def c(s):return ''.join(sum(([h,h,h]for h in[k for k,g in itertools.groupby(s)]),[]))
def v(s):
 while len(s)>=2 and s[-2]==s[-1]:s=s[:-1]
 return s+s[-1]+s[-1]
def a(n):
 r=''
 for w in n.split():
  if r:r+=' '
  ss=re.split('([AEIOU]+)', w.upper())
  for i,s in enumerate(ss):
   r += [v(s),s][any(j(t) for t in ss[i+1:])]if j(s)else[s,c(s)][i>0]
 return r
while 1:print a(raw_input('> '))

APL (Dyalog) , 175 byte

1↓' +'⎕R' '⊢'[AEIOU][^AEIOU]+ '⎕R{m/⍨1,3×2≠/m←⍵.Match}'([AEIOU])\1*([^AEIOU]*? )' ' [AEIOU]' ' [^ AEIOU]+' '([^AEIOU ])\1*'⎕R'\1\1\1\2' '&' '&' '\1\1\1'⊢'$| |^'⎕R'  '⊢1(819⌶)⍞

Provalo online!

⍞ richiedere l'immissione di caratteri

1(819⌶) converti in maiuscolo (819 ≈ Grande)

⊢ passare ulteriormente il risultato (serve per separare le stringhe e il 1)

'$| |^'⎕R' ' R eplace:
 alla fine, ogni spazio, e l'inizio
 → due spazi

⊢ passare ulteriormente il risultato (serve per separare due gruppi di stringhe)

'([AEIOU])\1*([^AEIOU]*? )' ' [AEIOU]' ' [^ AEIOU]+' '([^AEIOU ])\1*'⎕R'\1\1\1\2' '&' '&' '\1\1\1' R eplace:
 qualsiasi numero di vocali identiche e qualsiasi numero di non vocali e uno spazio
 → il tre volte vocali e le consonanti non modificati
 uno spazio e una vocale
 → stessi
 uno spazio e un gruppo di consonanti
 → stessi
 una corsa di consonanti identiche
 → tre di quelle vocali

'[AEIOU][^AEIOU]+ '⎕R{... } R eplace:
 una serie di non-vocali e uno spazio
 → il risultato della seguente funzione anonima con lo spazio dei nomi ⍵come argomento:
  ⍵.Match il testo che è stato trovato
  m← assegnare quello a m
  2≠/ coppia-saggio diverso-da
  3× moltiplicare per tre
  1, anteporre un
  m/⍨ uso che per replicarem

⊢ passare ulteriormente il risultato (serve per separare due stringhe)

' +'⎕R' ' R eplace:
 uno o più spazi
 → con un singolo spazio

1↓ rilascia la lettera iniziale (uno spazio)

JS (ES6), 138 134 129 byte

s=>s.toUpperCase()[r="replace"](/(\w)\1/g,"$1")[r](/[AEIOU](?=[^AEIOU]*( |$))/g,s=>s+s+s)[r](/\B./g,s=>/[AEIOU]/.test(s)?s:s+s+s)

WAAAYYY TOOO MAAANNNYYY BYYYTTEESS. Contiene AEIOU3 volte, ma non posso giocare a golf in uno.

-4 byte grazie a HyperNeutrino

Ungolfed

function v(str){
    return str.toUpperCase().replace(/(\w)\1/g,"$1").replace(/[AEIOU](?=[^AEIOU]*( |$))/g,s=>s+s+s).replace(/\B./g,s=>[..."AEIOU"].includes(s)?s:s+s+s);
}

Mi piace scrivere, non leggere il codice.

APL, 90 byte

{1↓∊{s←{⍵⊂⍨1,2≠/⍵}⋄x↑⍨¨(3⌈≢¨s⍵)⌊≢¨x←s⍵/⍨(1+2×{⌽<\⌽⍵}∨~∧∨\)⍵∊'AEIOU'}¨w⊂⍨w=⊃w←' ',1(819⌶)⍵}

Spiegazione:

• 1(819⌶)⍵: converti in maiuscolo
• w⊂⍨w=⊃w←' ',: suddiviso in spazi
• {... }¨: per ogni parola ...
  • s←{⍵⊂⍨1,2≠/⍵}: sè una funzione che divide una stringa in gruppi di caratteri corrispondenti contigui
  • ⍵∊'AEIOU': segna le vocali
  • (... ): vedi quali personaggi triplicare
    • ~∧∨\: tutte le consonanti oltre la prima vocale,
    • {⌽<\⌽⍵}: l'ultima vocale.
    • 2×: moltiplica il vettore bit per due,
    • 1+: e aggiungine uno. Ora tutti i personaggi selezionati hanno 3e il resto ha 1.
  • ⍵/⍨: replica ogni personaggio in ⍵base all'importo indicato
  • x←s: suddividilo in stringhe di caratteri corrispondenti e memorizzalo in x.
  • (3⌈≢¨s⍵): la lunghezza di ciascun gruppo di caratteri corrispondenti nella parola di input, con un massimo di 3.
  • ⌊≢¨: il minimo e la lunghezza dei gruppi in x.
  • x↑⍨¨: fai in modo che ciascun gruppo sia della stessa lunghezza
• 1↓∊: appiattisci il risultato e rilascia il primo carattere (lo spazio che è stato aggiunto all'inizio per aiutare con la divisione)

Python, 417 byte

Ecco un'implementazione di riferimento in Python. Non tremendamente golf.

import itertools,re
def j(s):return re.match('^[AEIOU]+$',s)
def c(s):return ''.join(sum(([h,h,h]for h in[k for k,g in itertools.groupby(s)]),[]))
def v(s):
 while len(s)>=2 and s[-2]==s[-1]:s=s[:-1]
 return s+s[-1]+s[-1]
def a(n):
 r=''
 for w in n.split():
  if r:r+=' '
  ss=re.split('([AEIOU]+)',w.upper())
  for i,s in enumerate(ss):
   r+=[v(s),s][any(j(t) for t in ss[i+1:])]if j(s)else[s,c(s)][i>0]
 return r

Prova con:

while True:
 print a(raw_input('> '))

Python 3 , 238 byte

def f(s):
 s=s.upper();k=[s[0]];s=''.join(k+[s[i]for i in range(1,len(s))if s[i]!=s[i-1]])
 for i in range(1,len(s)):k+=[s[i]]*(3-2*(s[i]in'AEIOU'and i!=max(map(s.rfind,'AEIOU'))))
 return''.join(k)
print(' '.join(map(f,input().split())))

Provalo online!

Perl 5 , 139 + 1 (-p) = 140 byte

$_=uc,s/^([^AEIOU]*)//,$s=$1,s/([^AEIOU])\1*/$1x(($q=length$&)>3?$q:3)/ge,s/.*?\K([AEIOU])\1*/$1x(($q=length$&)>3?$q:3)/e,print"$s$_ "for@F

Provalo online!

Gestisce persino il caso di prova "aaaabbbbc" secondo l'esempio.