Je n'aime pas les chaînes avec plus de trois voyelles d'affilée. Pouvez-vous écrire un programme qui supprime toutes les voyelles que je ne veux pas des mots?

Vous pouvez écrire un programme ou une fonction, en prenant une entrée via STDIN (ou l'alternative la plus proche), un argument de ligne de commande ou un argument de fonction et en sortant le résultat via STDOUT (ou l'alternative la plus proche), la valeur de retour de la fonction ou le paramètre de la fonction (out).

L'entrée est une chaîne contenant uniquement des caractères ASCII imprimables (0x20 à 0x7E, inclus).

La sortie est une chaîne contenant uniquement des séquences d'au plus 3 voyelles consécutives. S'il y a une séquence de plus de 3 voyelles consécutives dans la chaîne d'entrée, votre programme devrait produire une chaîne de sortie comprenant les trois premières voyelles rencontrées dans cette séquence, en éliminant toute autre voyelles consécutives.

Y n'est pas une voyelle aux fins de ce défi.

Il s'agit du code golf, donc le code le plus court (en octets) l'emporte.

Cas de test

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

Pyth, 21 octets

sfg3=Z&}rT0"aeiou"hZz

Essayez-le en ligne: démonstration ou suite de tests

Explication:

Je parcourt tous les caractères et garde une trace du nombre de voyelles que j'ai passées à l'aide d'un compteur. Chaque fois que je passe un caractère, qui n'est pas une voyelle, je remets le compteur à 0. Je remets des caractères, chaque fois que le compteur est> 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

Illisible , 1647 octets

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

Explication

Ce programme est équivalent à un pseudocode comme celui-ci:

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

avec les affectations de variables suivantes:

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)

Comme vous pouvez le voir, j'ai évité l'emplacement variable 0 car 0c'est une constante si longue à écrire.

Nous lisons donc chaque caractère et stockons la valeur dans cpet ch. Nous allons modifier cpmais garder chpour que nous puissions l'imprimer si nécessaire. Nous soustrayons successivement les nombres 65, 4, 4, 6, etc. de cppour vérifier s'il s'agit de chacun des 10 caractères de voyelle possibles en ASCII (notez que le tout dernier n'a pas besoin d'être une affectation).

vscontient toujours 3 de moins que le nombre de voyelles pouvant encore être imprimées. Il commence à 0, donc 3 voyelles peuvent être imprimées. Quand il atteint -3, nous arrêtons d'imprimer les voyelles.

Si nous rencontrons une non-voyelle (y compris l'espace), nous exécutons print(ch)suivi de vs = 0. Comme vous l'avez probablement deviné, cela réinitialise le compteur de voyelles.

Si nous rencontrons une voyelle , nous exécutons ((--vs)+4) ? print(ch) : (++vs). Décomposons cela:

• décrémenter vs;
• si la valeur est maintenant -4, nous sommes allés trop loin, alors n'imprimez rien, mais vsrevenez à -3ainsi nous continuerons à refuser d'imprimer les voyelles;
• sinon, imprimez le caractère.

Rétine , 25 octets

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

Essayez-le en ligne.

Substitution de regex assez simple. Cela fonctionne également pour le même nombre d'octets:

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

JavaScript (ES6), 42

En tant que fonction anonyme

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

Perl, 27 caractères

(Code de 26 caractères + option de ligne de commande de 1 caractère)

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

Pas grand-chose, juste une rare occasion dont je me souviens \K.

Exemple d'exécution:

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érieusement, 34 octets

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

Vidage hexadécimal:

2c3b9730bb604f6b226165696f75224f6b
642d593bbd2b2a3bbb343e604d40b0ee6a

Essayez-le en ligne

Il utilise le même algorithme que la réponse Pyth, mappant sur la chaîne tout en gardant une trace de la longueur de la course actuelle des voyelles dans un registre, l'incrémentant chaque fois que le caractère actuel est une voyelle et vérifiant s'il a dépassé la longueur autorisée, retourner 0 si c'est le cas, puis filtrer la chaîne d'origine avec ce filtre généré. Il sera beaucoup plus court une fois que nous pourrons utiliser la soustraction d'ensemble sur les chaînes. (Le Okpeut être supprimé et Okdpeut être remplacé par juste @). J'ai entendu dire que cette fonctionnalité arrivera dans la prochaine mise à jour ....

C, 166 octets

pas la réponse la plus courte de loin mais joliment golfée je pense ..

#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++;}

cas de test:

$ 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 octets

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

La réponse regex serait de la même longueur, mais qui utilise regex?

Java, 115 octets

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

Attend l'entrée comme paramètre de programme.

Sortie de test unitaire:

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

APL, 40 caractères

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

En anglais:

• 'aeiouAEIOU'∊⍨' ',⍵: trouver les voyelles (et ajouter un espace à casser lors de la rotation);
• (1-⍳4)⌽¨⊂: tourner 0, 1, 2, 3 fois (avec bouclage) en poussant vers la droite le vecteur booléen;
• ⊃+/ sum: les rotations et déballer
• 1↓4≠: trouvez le différent de 4 et supprimez le premier (pour rassembler l'espace que nous avons ajouté)
• ⍵/⍨: dans l'argument, ne conservez que l'élément dont la somme était différente de 4.

Perl 6 ,  36  35 octets

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

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

usage:

$ 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 octets)

#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);}}}}

(Un saut de ligne a été ajouté pour plus de clarté)

Scala, 107 octets

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 caractères

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

Tester:

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

Fichier x86 MS-DOS .COM , 44 octets 36 octets

Les fichiers .COM sont largement pris en charge de MS-DOS 1 à nos jours --- J'exécute dans dosemu, en utilisant uniquement les commandes 8086.

Réduit de 44 à 36 octets en utilisant REPNE SCASB pour tester les voyelles au lieu d'utiliser une commande distincte pour tester chaque voyelle.

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 octets

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

Exemple:

>> @(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.

Essayez-le à ideone .

V , 21 octets (sans concurrence)

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

Essayez-le en ligne!

Explication:

ñ[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

C'est à peine plus court que la solution la plus simple:

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

(22 octets)

Rubis, 44 octets

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

Exemple:

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