Não gosto de cordas com mais de três vogais seguidas. Você pode escrever um programa que remove todas as vogais que eu não quero das palavras?

Você pode escrever um programa ou função, recebendo entrada via STDIN (ou alternativa mais próxima), argumento da linha de comando ou argumento da função e emitindo o resultado via STDOUT (ou alternativa mais próxima), valor de retorno da função ou parâmetro da função (saída).

Entrada é uma sequência que contém apenas caracteres ASCII imprimíveis (0x20 a 0x7E, inclusive).

Saída é uma string que contém apenas execuções de no máximo 3 vogais consecutivas. Se houver uma execução de mais de 3 vogais consecutivas na cadeia de entrada, seu programa deverá produzir uma cadeia de saída incluindo as três primeiras vogais encontradas nessa execução, descartando outras vogais consecutivas.

Y não é uma vogal para os propósitos deste desafio.

Este é o código golf, portanto o código mais curto (em bytes) vence.

Casos de teste

"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."

Pitão, 21 bytes

sfg3=Z&}rT0"aeiou"hZz

Experimente on-line: Demonstration or Test Suite

Explicação:

Eu percorro todos os caracteres e acompanho quantas vogais eu passei usando um contador. Toda vez que passo um caractere, que não é uma vogal, redefino o contador para 0. Recolojo os caracteres sempre que o contador for> 4.

sfg3=Z&}rT0"aeiou"hZz   implicit: z = input string
                                  Z = 0
 f                  z   test every char T in z; keep chars, that return true:
        rT0                convert T to lower
       }   "aeiou"         test if T is a vowel
      &           hZ       logical and with Z+1, 
                           gives 0 if ^ is false, otherwise Z+1
    =Z                     update Z with this value
  g3                       test if 3 >= Z
s                       sum up all remaining chars and print

Ilegível , 1647 bytes

'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" '"" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" '"" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" '""' "" '"" "" "" "" "" "" "" "" "" "" "" "" "

Explicação

Este programa é equivalente ao pseudocódigo assim:

while (cp = (ch = read)) + 1 {
    (
        (cp -= 65) ?    // A
            (cp -= 4) ?     // E
                (cp -= 4) ?     // I
                    (cp -= 6) ?     // O
                        (cp -= 6) ?     // U
                            (cp -= 12) ?    // a
                                (cp -= 4) ?     // e
                                    (cp -= 4) ?     // i
                                        (cp -= 6) ?     // o
                                            (cp - 6) ?      // u
                                                0
                                            : 1
                                        : 1
                                    : 1
                                : 1
                            : 1
                        : 1
                    : 1
                : 1
            : 1
        : 1
    ) ? ((--vs)+4) ? print(ch) : (++vs) : {
        print(ch)
        vs = 0
    }
}

com as seguintes atribuições de variáveis:

0   (unused)   (13 bytes)
1   cp         ( 4 bytes; occurs 20× in the code)
2   vs         ( 7 bytes; occurs  5× in the code)
3   ch         (10 bytes; occurs  3× in the code)

Como você pode ver, evitei o slot variável 0 porque 0é uma constante tão longa para escrever.

Então, lemos cada caractere e armazenamos o valor em ambos cpe ch. Nós modificaremos, cpmas manteremos por chaí para que possamos imprimi-lo, se necessário. Subtraímos sucessivamente os números 65, 4, 4, 6 etc. de cppara verificar se é um dos 10 caracteres possíveis de vogal em ASCII (observe que o último não precisa ser uma tarefa).

vssempre contém 3 menos que o número de vogais que ainda podem ser impressas. Começa às 0, para que 3 vogais possam ser impressas. Quando chega -3, paramos de imprimir vogais.

Se encontrarmos uma não vogal (incluindo o espaço), executamos print(ch)seguidos porvs = 0 . Como você provavelmente adivinhou, isso redefine o contador de vogais.

Se encontrarmos uma vogal , executamos ((--vs)+4) ? print(ch) : (++vs). Vamos dividir isso:

• decremento vs;
• se o valor for agora -4, temos ido longe demais, por isso não imprimir nada, mas de incremento vsde volta para -3isso vamos continuar a recusar-se a imprimir vogais;
• caso contrário, imprima o caractere.

Retina , 25 bytes

i`([aeiou]{3})[aeiou]+
$1

Experimente online.

Substituição de expressões regulares bastante simples. Isso também funciona para a mesma contagem de bytes:

Ri`(?<=[aeiou]{3})[aeiou]

JavaScript (ES6), 42

Como uma função anônima

s=>s.replace(/[aeiou]+/gi,v=>v.slice(0,3))

Perl, 27 caracteres

(Código de 26 caracteres + opção de linha de comando de 1 caractere)

s/[aeiou]{3}\K[aeiou]+//gi

Não é grande coisa, apenas uma ocasião rara que me lembro de \Kexistir.

Exemplo de execução:

bash-4.3$ perl -pe 's/[aeiou]{3}\K[aeiou]+//gi' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

Sério, 34 bytes

,;ù0╗`Ok"aeiou"Okd-Y;╜+*;╗4>`M@░εj

Hex Dump:

2c3b9730bb604f6b226165696f75224f6b
642d593bbd2b2a3bbb343e604d40b0ee6a

Experimente online

Ele usa o mesmo algoritmo da resposta Pyth, mapeando a sequência e mantendo o controle do comprimento da execução atual das vogais em um registro, incrementando-o sempre que o caractere atual for uma vogal e verificando se excedeu o comprimento permitido, retornando 0, se sim, e filtrando a sequência original com este filtro gerado. Será muito mais curto quando pudermos usar a subtração de conjunto em strings. (O Okpode ser excluído e o Okdpode ser substituído por apenas @). Ouvi dizer que esse recurso está chegando na próxima atualização ....

C, 166 bytes

não é a resposta mais curta, de longe, mas bem jogado, acho ..

#define V v[1][i]!=
#define P printf("%c",v[1][i]),j
j;main(i,v)char**v;{for(i=0;V 0;i++)(V 97&V 'e'&V 'i'&V 'o'&V 'u'&V 65&V 69&V 73&V 79&V 85)?P=0:j>3?j++:P++;}

caso de teste:

$ a.exe "We're queueing up for the Hawaiian movie."

We're queung up for the Hawaiin movie.

$ wc -c vowels.c 

166 vowels.c

Mathematica, 68 bytes

a=Characters@"aeiouAEIOU";StringReplace[#,b:a~Repeated~{3}~~a..:>b]&

A resposta do regex teria o mesmo tamanho, mas quem usa o regex?

Java, 115 bytes

class a{public static void main(String[] a){System.out.println(a[0].replaceAll("(?i)([aeiou]{3})[aeiou]*","$1"));}}

Espera entrada como parâmetro do programa.

Saída do teste de unidade:

Aei
screeen
We're queung up for the Hawaiin movie.

APL, 40 caracteres

{⍵/⍨1↓4≠⊃+/(1-⍳4)⌽¨⊂'aeiouAEIOU'∊⍨' ',⍵}

Em inglês:

• 'aeiouAEIOU'∊⍨' ',⍵: encontre as vogais (e coloque um espaço para quebrar na rotação);
• (1-⍳4)⌽¨⊂: gire 0, 1, 2, 3 vezes (com contorno) empurrando para a direita o vetor booleano;
• ⊃+/ sum: as rotações e unbox
• 1↓4≠: encontre o diferente de 4 e remova o primeiro (para reunir o espaço que acrescentamos)
• ⍵/⍨: no argumento, mantenha apenas o elemento em que a soma foi diferente de 4.

Perl 6 ,  36  35 bytes

{S:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/} # 36 bytes

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' # 34 + 1 = 35 bytes

uso:

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

C (205 bytes)

#include <stdio.h>
#define T(x)for(i=0;i<10;++i){if(v[i]==x){b=x;m=1;break;}}putchar(c);
main(b,c,i,m){char v[]="aeiouAEIOU";
while((c=getchar())!=EOF){if(!m){T(c);}else{if(b==c)continue;else{m=0;T(c);}}}}

(Uma quebra de linha adicionada para maior clareza)

Scala, 107 bytes

readLine.foldLeft("",0)((a,n)=>if(!"aeiou".contains(n|32))a._1+n->0 else if(a._2>2)a else(a._1+n,a._2+1))_1

Javascript ES6, 43 caracteres

s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")

Teste:

f=s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")
;`"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."`
.replace(/"/g,"").split("\n").every(s=>f((s=s.split(" => "))[0])==s[1])

x. arquivo .COM do MS-DOS , 44 bytes 36 bytes

Os arquivos .COM são amplamente suportados pelo MS-DOS 1 até o presente --- Estou executando no dosemu, usando apenas os comandos 8086.

Reduzido de 44 para 36 bytes usando o REPNE SCASB para testar vogais em vez de usar um comando separado para testar cada vogal.

Hex dump, reversible using `xxd -r -seek -256`:
0100: b3 03 43 b4 08 cd 21 88 c2 24 df b1 05 bf 1f 01   ..C...!..$......
0110: f2 ae 74 02 b3 05 4b 74 e9 b4 02 cd 21 eb e4 41   ..t...Kt....!..A
0120: 45 49 4f 55                                       EIOU

Unassembled using debug:
0100 B303    MOV BL,03     ; initialize counter to 3 (will increment by 1 to be 4)
0102 43      INC BX        ; increment counter--runs each time it hits 0 so it never goes <0
0103 B408    MOV AH,08     ; 
0105 CD21    INT 21        ; with AH=8, read 1 char without echo
0107 88C2    MOV DL,AL     ; copy input for potential output
0109 24DF    AND AL,DF     ; make input uppercase for testing
010B B105    MOV CL,05     ; count of 5 vowels to test against
010D BF1F01  MOV DI,011F   ; location of first vowel to test against
0110 F2AE    REPNE SCASB   ; test input against each vowel
0112 7402    JZ 0116       ; if input was not a vowel:
0114 B305    MOV BL,05     ;    reset counter to 5 (will decrement by 1 to be 4)
0116 4B      DEC BX        ; decrement counter regardless
0117 74E9    JZ 0102       ; if hit 0 (fourth or later vowel): goto 102
0119 B402    MOV AH,02     ; 
011B CD21    INT 21        ; with AH=2, print char
011D EBE4    JMP 0103      ; go to 103 for next character

bytes 011f-0123 contain the uppercase vowels AEIOU

Matlab / Octave, 54 bytes

@(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

Exemplo:

>> @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')
ans = 
    @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

>> ans('We''re queueing up for the Hawaiian movie.')
ans =
We're queung up for the Hawaiin movie.

Experimente em ideone .

V , 21 bytes (não competitivo)

ñ[aeiou]ñÍãqû3}úsq*

Experimente online!

Explicação:

ñ[aeiou]ñ                     "Assign the string `[aeiou]` to register 'q'
         Íã                   "Search and replace on multiple lines (case insensitive):
           <C-r>q             "Register 'q'
                 û3}          "Repeated 3 times
                    ús        "Mark the following to be removed:
                      <C-r>q* "Register 'q' repeated any number of times

Isso é apenas um pouco mais curto que a solução mais direta:

Íã[aeiou]û3}ús[aeiou]*

(22 bytes)

Ruby, 44 bytes

><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')

Exemplo:

% ruby -e "$><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')" <<< "
Aeiou
screeeen
We're queueing up for the Hawaiian movie.
Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.