LOOOOONG TEEEEEXT

Question

Definition of long text

Long text usually shows emphasis, for instance, loooooool or yaaaaaaaaaay. Usually the vowel is replicated many times. In this challenge we require:

• At least 3 times, which means yaaay and yaaaay are allowed, but yay and yaay are not.

• Consistent, which means that shoes can turn out be shoooeees or shooooeeees but not shoooeeees or shooooeees. Of course, it seems that no one would do that, however, this is to reinforce the next law.

• Undoubling, which means beeping turns out to be beeepiiing or beeeepiiiing but not beeeeeepiiing or beeeeeeeepiiiing. This is not the case for long text, but such makes this challenge non-trivial.

• Thus, the long text might turn out shorter than the original text, that is, aaaaa can turn out to be aaa.

Your challenge

Input

Your input will be a sentence, that is, you may not assume there are only words. We do not guarantee all will be English words, so look out for theeeeeeeeese.

Output

The long text for the input.

Test cases

We assume you repeat 3 times.

The fox yawns... => Theee fooox yaaawns...

Everything is good!!!!! => Eeeveeerythiiing iiis goood!!!!! and NOT EEEveeerythiiing iiis gooooood!!!!!

Eeny, meeny, miny, moe => Eeeeeeny, meeeny, miiiny, moooeee

AAARGH => AaaRGH

Weeeeeeeeheeeeeee => Weeeheee

Note the treatment of capital letters: The first letter remains capital, and the others are lowered. eE will be eeeEee, they won't be the same. "Undoubling" only happens for letters which are of the same case (like ee or AA, but not for Ee)

Only the letters from a, e, i, o, and u are vowels, case insensitive.

Answer 1

Vyxal d, 10 bytes

ĠƛhA[h:d⇩+

Try it Online!

Nice simple answer.

Explained

ĠƛhA[h:d⇩+
Ġƛ         # to each group of consecutive characters: 
  hA       #   is the character a vowel?
    [      #   if so:
     h:d   #     Push the character and a string with two copies of that character
        ⇩+ #     and add the lowercase version of that to the character. 
# The -d flag flattens all sublists to depth 1 and then sums the list.

Answer 2

Perl 5 -p, 29 bytes

Now handles undoubling thanks to [@Jo King]!

s/((?i)[aeiou])\1*/$1\L$1$1/g

Try it online!

Answer 3

Jelly, 15 bytes

ŒgµŒlṁ3fØcȯaẆḢ)

Try it online!

Œgµ           )    For each run of consecutive equal elements:
   Œl              Lowercase it,
     ṁ3            mold it to length 3,
       fØc         remove non-vowels,
          ȯ        and substitute the original run if that left it empty.
           aẆḢ     Fix the capitalization:
           a       vectorizing logical AND with
            Ẇ      each sublist of the run, individually
           a       because of something to do with how vectorization handles depth?
             Ḣ     and take the head of the resulting list.

Answer 4

Python, 78 bytes

lambda s:re.sub(r"([aeiouAEIOU])\1*",lambda m:m[1]+2*m[1].lower(),s)
import re

Attempt This Online!

I don't read Perl unless under duress, but if would I'd have to note that this looks very similar to @Dom Hastings' answer.

Answer 5

JavaScript (ES6), 63 bytes

Repeats 3 times.

s=>s.replace(/([AEIOUaeiou])\1*/g,([c])=>c+(c+c).toLowerCase())

Try it online!

Answer 6

Retina, 28 bytes

((?i)[aeiou])\1*
$1$l$1$l$1

Try it online! Link includes test cases. Explanation: Port of @DomHastings' Perl answer, but Retina's $l operator only operates on the next token, so either as here it has to be repeated for each token to be lowercased or the letters need to be grouped $1$l$($1$1 which here happens to be the same length as the group does not need to be explicitly closed. Unfortunately Retina's repetition operator does not help here as $12*$l$1 parses as ${12}*$($l$1) so the best we can do is ${1}2*$l$1 which is still the same length. Edit: Saved 1 byte thanks to @DomHastings by porting his (?i) golf from his answer.

Answer 7

05AB1E (legacy), 16 bytes

γεDlžMÃĀiÙDlDJ]J

Uses the legacy version of 05AB1E, because there is a bug in the new version with Ā (Python-style truthify builtin) on empty strings "", incorrectly giving a truthy result instead of falsey.

Try it online.

Explanation:

γ              # Split the (implicit) input-string into parts of equal adjacent
               # characters
 ε             # Map over each part:
  D            #  Duplicate the current part
   l           #  Lowercase the copy
    žM         #  Push the vowels constant "aeiou"
      Ã        #  Only keep those characters from the lowercase copy
       Āi      #  If it's non-empty (thus a part with vowels):
         Ù     #   Uniquify to a single character
          D    #   Duplicate it
           l   #   Lowercase the copy
            D  #   Duplicate that again
             J #   Join the three characters together
 ]             # Close the if-statement and map
  J            # Join everything back together
               # (after which the result is output implicitly)

Answer 8

Husk, 23 bytes

ṁ?oS:oR2_←Iȯ€"AEIOU"a←g

Try it online!

ṁ?oS:oR2_←Iȯ€"AEIOU"a←g
                      g # group identical adjacent letters   
ṁ                       # and, for each group, do this and combine the results:
  ?                     # if
                     ←  # the first element
                    a   # in uppercase form                    
           ȯ€"AEIOU"    # is one of "AEIOU"
         ←              # then get the first element,
        _               # lowercase it,
      R2                # duplicate it,
   S:o                  # and add that to itself;
          I             # otherwise leave the group unchanged

Answer 9

Python, 82 80 79 bytes

lambda s,*e:''.join([c,(c+2*c.lower())*(e!=c)][(e:=c)in"AEIOUaeiou"]for c in s)

Attempt This Online! First time realising that you can use the walrus operator (:=) in list comprehension to store the previous value of the iterable. Just needs to be initialised

-1 byte thanks to @Unrelated String

Answer 10

Japt, 14 bytes

r"(%v)%1*"Ï+²v

Try it (Includes all test cases)

r"(%v)%1*"Ï+²v     :Implicit input of string
r                  :Replace
 "(%v)%1*"         :Regex /([AEIOUaeiou])\1*/g
          Ï        :Pass the first submatch (i.e., the first character in the match) through the following function
           +       :Append
            ²      :The character duplicated
             v     :And lowercased

Answer 11

Factor + grouping.extras math.unicode sequences.repeating, 119 111 109 102 100 95 bytes

[ [ ] group-by values [ dup "aeiouAEIOU"⊂ [ 3 cycle 1 cut >lower append ] when ] map-concat ]

Attempt This Online!

Unfortunately Factor's regular expressions are very limited by design so they can't be used to help much. This is still maybe quite golfable regardless.

• [ ] group-by values Break the input into groups of contiguous equal characters.
• [ ... ] map-concat Map each group to a sequence, all of which get concatenated together in the end.
• dup "aeiouAEIOU"⊂ Is it a group of vowels?
• [ 3 cycle 1 cut >lower append ] when Make it length three and 'capitalize' it if so. (i.e. "aaa" -> "aaa", "AAA" -> "Aaa")

Answer 12

Retina 0.8.2, 63 47 43 bytes

([AEIOUaeiou])\1*
$1$1$1
rT`L`l`\1([AEIOU])

This can definitely be shorter.. It can, see @Neil's Retina answer. My answer uses the older version, which didn't had builtin $l yet (nor $1$1$1 to 3*$1).
I again have the feeling this can be shorter.. And it can: -16 bytes thank to @Neil, and I've been able to golf it slightly more.

Try it online.

Explanation:

Get all consecutive matches of 1 or more of the same vowels, and shorten/extend them to three of these vowels:

([AEIOUaeiou])\1*
$1$1$1

Lowercase every match of two adjacent uppercase vowels by transliterating in reverse order:

rT`L`l`\1([AEIOU])

Answer 13

V (vim), 34 bytes

:%s/\v([aeiouAEIOU])\1*/\1\L\1\1/g

Try it online!

Very similar to other regex based solutions.

Answer 14

C (gcc), 125 121 119 bytes

• -2 thanks to ceilingcat

Scans for vowels and coalesces duplicates, lowercasing the extra output vowels.

i,c;f(char*s){for(;c=*s++;){if(index("aeiou",c|32)){for(;i=c==*s;s++);for(;i<3;)putchar(c|!!i++*32);}else putchar(c);}}

Try it online!

Answer 15

Charcoal, 29 bytes

ＦＳ¿¬⁼ιψ«ι≔ωψ¿№AEIOU↥ι«≔ιψ↧ι↧ι

Try it online! Link is to verbose version of code. Explanation:

ＦＳ

Loop over the characters of the input string.

¿¬⁼ιψ«

If this is not a duplicate vowel, then:

ι

Output the current character.

≔ωψ

Clear the last duplicate vowel.

¿№AEIOU↥ι«

If this is a vowel, then:

≔ιψ

Store the last vowel.

↧ι↧ι

Output the lowercased vowel twice.

Answer 16

Go, 440 428 bytes

import(."regexp";."strings")
type S=string
func f(s S)S{M,Q,N,x:=MustCompile,Repeat,NewReplacer,`((?i)[aeiou]`
L:=[]S{}
for _,r:=range`AEIOU`{c:=S(r);l:=ToLower(c);L=append(L,Q(c,3),c,Q(c,2),c,Q(l,3),l,Q(l,2),l)}
R:=N(L...)
l:=R.Replace(s)
for;l!=s;l,s=R.Replace(l),l{}
return N([]S{"AAA","Aaa","EEE","Eee","III","Iii","OOO","Ooo","UUU","Uuu"}...).Replace(M(x+`)`).ReplaceAllString(M(x+`+)`).ReplaceAllString(l,"$1"),"$1$1$1"))}

Attempt This Online!

What no regex backtracking does to a mfer.

Looking at other answers, Golang lacks the following regex features that other answers are dependent on:

• Backtracking (abc)\1
• Lowercase mode \L

So, I've had to make do with a mix of regex and pure string replacement using strings.Replacers to handle the lack of backtracking and lowercase mode.

Edits

• -12 bytes by moving the code for initializing the translation pairs for R out of the function.

Explanation

import(."regexp";."strings") // boilerplate imports
type S=string                // alias string for byte saving
func f(s S)S{                // function of string to string
// define the following:
// - abbreviations for commonly-used functions
// - a partial shared regex
M,Q,N,x:=MustCompile,Repeat,NewReplacer,`((?i)[aeiou]`
// create a new replacer that maps "AAA"=>"A", "AA"=>"A", etc
R:=N(func()(L[]S){for _,r:=range`AEIOU`{c:=S(r);l:=ToLower(c);L=append(L,Q(c,3),c,Q(c,2),c,Q(l,3),l,Q(l,2),l)};return}()...)
// do the replacement...
l:=R.Replace(s)
// ...while the input hasn't changed
for;l!=s;l,s=R.Replace(l),l{}

return
// create another replacer, for the uppercase case
N([]S{"AAA","Aaa","EEE","Eee","III","Iii","OOO","Ooo","UUU","Uuu"}...).Replace(
// match `((?i)[aeiou])`...
    M(x+`)`).ReplaceAllString(
// replace (de-duplicated) vowels...
    M(x+`+)`).ReplaceAllString(l,"$1"),
// with 3 copies of the vowel 
    "$1$1$1"))}

Answer 17

Julia 1.0, 59 bytes

!x=replace(x,r"((?i)[aeiou])\1*"=>i->i[1]lowercase(i[1]^2))

Try it online!

sadly Julia doesn't seem to support \l or \L