[Question]
  [
# Introduction
The current coronavirus disease is officially named **COVID-19**, from the 3 words **co**rona **vi**rus **d**isease, and the year 20**19**. (Technically it's coronavirus, making 2 words, but whatever...)
Given this example, we can apply this naming convention to name other potential diseases.
# Challenge
You will be given 3 words and a year.
* Take the first letters of the first 2 words, up to and including the first vowel, and append them together.
* Then, append the first letter of the 3rd word.
* Finally, append the character `-`, followed by the last 2 digits of the year.
Thus, `corona,virus,disease,2019 -> co + vi + d + - + 19 -> covid-19`.
### Challenge rules
* It is guaranteed that each of the three words have at least one vowel. For the purposes of this challenge, vowels are defined as the letters `a, e, i, o, u`.
* You may assume that words consist only of lowercase letters `a-z`, or only uppercase letters `A-Z` if you prefer. Your output may be in either case.
* It's guaranteed that the date is exactly four digits.
* Input may be specified in any format, as long as there is a delimiter between the words. For example, `['corona', 'virus', 'disease', '2019']`, `corona,virus,disease,2019`, `[['corona', 'virus'], 'disease', 2019]` and `corona virus disease 2019` are all valid inputs.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer wins.
# Example test cases
```
corona,virus,disease,2019 -> covid-19
computer,addiction,syndrome,1970 -> coas-70
code,golf,fun,2020 -> cogof-20
a,ba,ca,1234 -> abac-34
tree,string,create,9000 -> trestric-00
love,time,cholera,1985 -> lotic-85
```
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~83~~ 81 bytes
```
lambda a,b,c,d:g(*a)+g(*b)+c[0]+"-"+d[2:]
g=lambda c,*s:c[:c in"aeiou"]or c+g(*s)
```
[Try it online!](https://tio.run/##ZY/BioMwEIbvPkXISeukRLtQFOyLuB7GJLoBTSSJhbLss7uxtexhL3P4/u8fZpZH@LLmsg3N5zbh3EskCD0IkPWYnjDL4@yzXLS8yymjuWzLukvG5nAFnHwt2loQbSgqbVfaWUfEXvPZpufFukD8wyfJEPmkjYrmDs4@SG3qhBAPjjRkxiX1wUXs9AJP8@yXSYeUshvNsigeh/2X/duEl@iUj9KQHoUdLU6b8Aawr4S/HAbafsdS07ifjmabsM4ahLt2qwepvUKvoORFRdiNCHvXkhVVIuy8rEE5QCm1CNoa8A8jnZ0VFNWVv2T07MqjKxWMdhpgWE1cVR7paAdW8iQegiAQivLysQfYo2CXjyQ4pWB/0owgnMKgoOL82Y3RHgjG@S8 "Python 3 – Try It Online")
*-2 bytes thanks to @JonathanAllan!*
### Explanation:
`g` is a recursive function that takes in a splatted string and return the string, truncated after the first vowel.
* `lambda c,*s` gather the splatted string into the first character `c` and the rest `s`.
* `c[:c in"aeiou"] or c+g(*s)` evaluates to:
	+ if `c` is a vowel, then `c[:c in"aeiou"]` evaluates to `c[:1]` which is `c`. Since `c` is Truthy, it is returned.
	+ if `c` is not a vowel, then `c[:c in"aeiou"]` evaluates to `c[:0]` aka the empty string. The empty string is Falsy, so `c+g(*s)` (the recursive case) is returned.
  
**Old solution, kept here for sentimental reason**
### [Python 3](https://docs.python.org/3/), 89 bytes
```
lambda a,b,c,d:g(a)+g(b)+c[0]+"-"+d[2:]
g=lambda s:s[:[x in"aeiou"for x in s].index(1)+1]
```
[Try it online!](https://tio.run/##Zc/PboQgEAbwu09BOGkcNuhu0mjivoj1gICWRMEwuFnT9Nkt7p/00CPf95vJsGzhy9nzPjSf@yTmXgkioAcJqh5TkeVj2me5bHmXU0Zz1ZZ1l4zNS2KNbd3eibFUaONWOjhPjifB7mSs0ve0yPKi2828OB8Ibpgkh5mM1Q@24QmDMrZOCEHwpCGzWFIMPsbeLPCQJ1wmE1LKrjTLInwd@B/jW8ITeo0RDelr4IgWb2x4B3CshL8eBtp@x6Gm8T8dzXbpvLMCbsavCMqgFqih5EVF2JVIdzOKFVUi3bysQXsQShkZjLOAm1XezRqK6oM/sUD2waNVGkY3DTCsNq4qX@3oBlbyJB4iQAooyvPlKEQvJDtfkuC1huOTdgTptQgaKs4fs7E6Csk4/wU "Python 3 – Try It Online")
[Answer]
# Java 8, ~~82~~ ~~74~~ ~~71~~ ~~67~~ 61 bytes
```
s->s.replaceAll((s="(.*?[aeiou]).*,")+s+"(.).*,..","$1$2$3-")
```
-8 bytes thanks to *@ValueInk*.  
-6 bytes thanks to *@Nevay*.
Input as a single comma-separated string like in the challenge description.
[Try it online.](https://tio.run/##fVE9a8MwEN3zKw6Rwa4vwk4KJSlpKZ06NB06hgwXWQ5KbclIckoI/u2u7DjdWhDiPt5793Q60olmx/yrEyU5B@@k9GUCoLSXtiAhYdOnAJ/eKn0AEY2Bix9DvZ2Ey3nySsAGNKyhc7Mnx62sy0B@KcsocmsW8bvnLUllml3M75DFiUtCsY85Z8im2XQ@XcxY3PWi4dTNvgySo/LJqByq4Gwcvt0BxVdbhbE3R146/0pOwgq0/IYb9MKEsUYTnpRtHObKyQDCeZotGUJoVnUT3oqU50p4ZTS6s86tqSRmy4f0isklHkxZYNHowJwPVcI9oSDM5ov7PvdWSnTDVBRWkpe4TNOUtaPVsMOz87LipvG8DjBf6oi96TB@BcCSm/9hsX/BPxo/4FmiuYh@Kf9xxl47fFfb/QA)
**Explanation:**
```
s->                // Method with String as both parameter and return-type
  s.replaceAll(    //  Regex-replace the match with the replacement (see below)
                   //   As match:
    (s="(.*?[aeiou]).*,")+s
                  //     Repeat this String twice (re-using the input-variable)
    +"(.).*,..",  //     and append this String
    "$1$2$3-")    //    And as replacement: use this String
```
*Regex explanation:*
```
(.*?[aeiou]).*,(.*?[aeiou]).*,(.).*,..  # MATCH:
 .*                                     #  0 or more characters
   ?                                    #  which are optional to lower their priority
    [aeiou]                             #  followed by a vowel
(          )                            #  Stored in capture group 1
            .*                          #  Followed by some optional characters
              ,                         #  and a comma
               (.*?[aeiou]).*,          #  Same again, with capture group 2
                               .        #  Then a single character
                              ( )       #  Stored in capture group 3
                                 .*     #  Followed by some optional characters
                                   ,    #  and a comma again
                                    ..  #  Followed by 2 characters
$1$2$3-                                 # REPLACEMENT:
$1$2$3                                  #  The contents of groups 1, 2, and 3
      -                                 #  Appended with a literal "-"
```
Note how the two trailing digits of the input-String aren't touched, and will still be there after the replacement.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 26 bytes
```
\B.*¶\d.
-
([aeiou]).*¶
$1
```
[Try it online!](https://tio.run/##FctBCsIwEEbhfc6hUOW3JFWQbr2CSys4JtMSsIlMEsGLeQAvFuv28T3h7APVdXO@oQ6ndvv9DK5VO9VciH0s180/qZWp1UaJgfDyUhKcT0yJ0WnTKxvnZ8ksIOe8zT4GpHdwEmeG6Y96AY4xxceIsYTl6bQi3AmWYLr9QWVhRsriwwQrTJnRa61/ "Retina 0.8.2 – Try It Online") Link includes test suite. Takes lowercase words and year on separate lines, but test suite splits each test case on commas automatically for the convenience of the user. Explanation:
```
\B.*¶\d.
-
```
Truncate the last word after the first character, remove the first two digits of the year, and join the two together with a `-`.
```
([aeiou]).*¶
$1
```
Truncate each of the first two words after the first vowel, and join everything together.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~18~~ 17 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ḣe€ØcM$ḢƊ€⁴Ḣ”-3⁵ṫ
```
A full program accepting arguments `['word1', 'word2'] 'word3' 'year'` which prints the result.
**[Try it online!](https://tio.run/##y0rNyan8///hjsWpj5rWHJ6R7KvycMeiY11AzqPGLUDmo4a5usaPGrc@3Ln6////0eolRamp6joK6sUlRZl56eqx/9WTixJLUtX/q1saGBioAwA "Jelly – Try It Online")**
### How?
```
ḣe€ØcM$ḢƊ€⁴Ḣ”-3⁵ṫ - Main Link: [word1, word2]
         €        - for each (w in [word1, word2]):
        Ɗ         -   last three links as a monad:
      $           -     last two links as a monad:
  €               -       for each (character, c of w):
 e                -         (c) exists in?:
   Øc             -           vowels = "AEIOUaeiou"
     M            -       maximal indices (i.e (sorted) indices of vowels in w)
ḣ                 -     head to index (vectorises across the list of indices):
       Ḣ          -     head (the first such head-to-index result)
          ⁴       - program's 2nd argument, word3
                  - ...N.B. a nilad here forces Jelly to smash the previous list
                  -         together and print to STDOUT.
           Ḣ      - head - i.e. the first character of the third word
            ”-    - literal '-' character
                  - ...N.B. again a nilad here forces a print of the previous
                  -         result, the first character of the third word.
              3   - literal three
               ⁵  - program's 3rd argument, year
                ṫ - tail from index (i.e. "2019" -> "19")
                  - implicit print (of these two characters)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0 [`-P`](https://codegolf.meta.stackexchange.com/a/14339/), 15 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
®¯ÒZb\vÃpVÎ'-W¤
```
Saved a byte thanks to @Shaggy (`s2` -> `¤`)
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&flags=LVA&code=rq/SWmJcdsNwVs4nLVek&input=WyJjb3JvbmEiCiJ2aXJ1cyJdCiJkaXNlYXNlIgoiOTAwMCI)
```
®¯ÒZb\vÃpVÎ'-W¤           Input: ["corona" "virus"] "disease" "2019"
®      Ã                  Map ["corona" "virus"] to 
   Zb\v                     Index of first vowel in word
  Ò                         Add one
 ¯                          Slice 0..index+1
                          ["co" "vi"]
        p                 Append the following:
         VÎ               A) First letter of third word
           '-             B) "-"
             W¤           C) Last two digits of year
                          ["co" "vi" "d" "-" "19"]
-P                        Implicit join -> "covid-19"
     
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, ~~58~~ 55 bytes
```
sed -E 's/([aeiou]).*/\1/;3s/\B.*/-/;4s/..//'|tr -d \\n
```
[Try it online!](https://tio.run/##Jcg5DoAgEADAnlfQeSSwGG2MnYmvEAvUjdJgwmLn39erm8zsaGcmXKUaZEaQjw79cU6FLsFW0NUEtn@soGsItAbIrhSlWqW1gTlFREEp@rCJJaJLKFpjzPf8P//P798 "Bash – Try It Online")
*3 bytes shorter through the use of \B, thanks to user41805.*
Accepts newline-delimited input on stdin.
Output on stdout.
[Answer]
# [Python 3](https://docs.python.org/3/), 86 bytes
```
lambda t,c,y:''.join(re.sub('([aeiou]).*',r'\1',s)for s in t)+c[0]+'-'+y[2:]
import re
```
[Try it online!](https://tio.run/##NVHLboMwELzzFRYX242JgESKgkSP/YLeCAdjTOoq2MiPSAjx7dRLmsvs7O7MrrWeZv9j9Gkb6tv24GPXc@SZYHOF8fHXKE2sPLrQEUwaLpUJLT1@YGbxrcDM0cFY5JDSyNODaPL2gDN8mJuyahM1TsZ6ZOXmpfMO1YgkhKTCWKN5ytKnssHF2CsnuZORlXlxTSmLkqfqs52/HOMUvLRRwfteCa@MjtzNurdmBGNxveQvI3fZTl@@Hpp38xhiGILeV5T/yrsZsvIthfd0AAKgKE9nEPGOi2ynoPFWwjjnrdJ3kFrJPVSueb7PjAJoimxPE5rYevm2QVYB30J5KU6YoS/@cO/CWeA1gQN6JvcTwpmqBHHWwQfUPkGuHgiJOYUCTdAUd3sypAtfGVo6AAEwryj7RItb0WIbV9eyXVO6/QE "Python 3 – Try It Online")
Inputs the first two words in a tuple followed by the third word and then year as a string.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 48 bytes
```
$p='(.*?[aeiou]).*? 'x2;s/$p(.).*(..)/$1$2$3-$4/
```
[Try it online!](https://tio.run/##FYtBCsIwEADvvmIPgbZC0zQqUkR8iHgIzVYCaTZkG9HPG@NtBmYiJn8qRcRr08r97W7QUX50FaF56wsPIrayaitlN4hRaHHoxXEoZaZEwcDLpcxgHaNhBK3GaTfTGvOGCYy1bt4cBeBPsIlWhHE6qxpYhCf5BZYc6qPVl@K/49JH/wM "Perl 5 – Try It Online")
Basically, a straight forward regex to pick out the relevant parts and put them back together.
[Answer]
# [QuadS](https://github.com/abrudz/QuadRS), 33 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Takes lowercase multi-line input.
```
∊('-',⍨⊃)¨@3⊢⍵
^.*?[aeiou]|\d.$
&
```
[Try it online!](https://tio.run/##KyxNTCn@//9RR5eGuq66zqPeFY@6mjUPrXAwftS16FHvVq44PS376MTUzPzSWK6YFD0VLrX//5Pzi/LzErnKMotKi7lSMotTE4tTuYwMDC0B "QuadS – Try It Online")
`&` Search for and return
`^.*?[aeiou]|\d.$` initial letters ending with a vowel, or a trailing digit with another character
`⊢⍵` on that
`(`…`)¨@3` **at** the third match:
 `⊃` pick the first character
 `'-',⍨` prepend a dash
`∊` **ϵ**nlist (flatten)
[Answer]
# [Python 3](https://docs.python.org/3/), [86 bytes](https://mothereff.in/byte-counter#lambda%20a%2Cc%2Cd%3A%27%27.join%28re.sub%28%22%28%5Baeiou%5D%29.%2a%22%2Cr%22%5C1%22%2Cx%29for%20x%20in%20a%29%2Bc%5B0%5D%2B%22-%22%2Bd%5B2%3A%5D%0Aimport%20re)
```
lambda a,c,d:''.join(re.sub("([aeiou]).*",r"\1",x)for x in a)+c[0]+"-"+d[2:]
import re
```
Accepts input like `["corona", "virus"], "disease", "2019"`
[Try it online!](https://tio.run/##RZDBboMwEETP5SssXwLNggxEiohEf4RwMLahrsBG9hIlX09NSJTbSG92d2bnB/5aU659fV1HPnWSEw4C5OVwyP6sNrFTmV@6mMYNV9oubZJ9U3D0mlO4J7115E60ITw5ioa1R5rSo2yKSxvpabYOiVMrKo@e1IRSKqyzhsNNu8WD1F5xr6BgeUXSHyLsTcs0ryJhp3lB5YBLqQVqa8A/jHR2UpBXZ7abuU/PLHilgsGOPfSLCauKFx1snxYs4tCFOhzyojxtgHdcpOUpQqcUeHTaDCCc4qigYuw5G9AGRMpYSJz5edQ4aqN8nETRVhi3ws9Sl@hLmxDVA@Fmq4i7PabbIpq8cSC7eGPYmFMYQB83Owvvg5etyduPLj6ybMPYHEJjHO5BeC4@L9d1UMn6Dw)
[Answer]
# JavaScript (ES6), ~~65~~ 63 bytes
Takes input as 4 distinct strings.
```
(a,b,[c],[,,d,e])=>a.match(r=/.*?[aeiou]/)+b.match(r)+c+'-'+d+e
```
[Try it online!](https://tio.run/##ZY/BaoQwEIbvfQrxsloTje7C4sH2QcTDmEQ3RTNLEoU@vU26CIvmMDMM/3x8@YEVLDfq6ahGIbeh2RIgPWl5R1pCBJFd2nxBPoPjj8Q0Rf753YJUuHRFmvX7Ps14dqGXTGRy46gtTjKfcEyGJOZoUENM4lWZxfoulJVgpZ8qVtZx9HppGhVFxHFVgpb1xwkyPxcnjT8CIRR3CrWf7a8WBufAKus7i3cIWHpnZ4YIwRGnwbdh0f8GFdsNDiIjDrQ6QcJH@lB4KGV1vR3O3yHQA6fX25HhjAwi1hmlx4AyElzY1Iy92bwYPhyCnDK2/QE "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 71 bytes
Takes input as `["word1", "word2", "word3", "year"]`.
```
a=>'012-3'.replace(/\d/g,i=>a[i].match([,,/./,/..$/][i]||/.*?[aeiou]/))
```
[Try it online!](https://tio.run/##bY/daoQwEEbv@xQihdViTNSFxQu3D2K9mE2im6IZSaJQ2He3Sf9o1wYyMwxfDievsILlRs2OaBRy65sNmvOBFSWpDrmR8whcJvRF0CFTzRla1eUTOH5N2iyjOfU3f6SdX99uNH96bkEqXDqaphtHbXGU@YhD0idtzNGghjiLV2UW67tQVoKVfipZUcfR5@nSNKI04rgqQYr6YY@Z5sVJ45@BEIo7hdrP9k0Lg1OgFfWJxT8YsOTE/qGIEB1w7H3rF/1hUbJvi3uZAXtS7jHhO5dQeChFWR3vAH8wcAFOquOO4owMMtYZpYcAMxJc2NSM/TL6ovh0SHLC2PYO "JavaScript (Node.js) – Try It Online")
[Answer]
# [Icon](https://github.com/gtownsend/icon), 95 bytes
```
procedure f(a,b,c,d)
return a[1:1+upto(t:='aoeiu',a)]||b[1:1+upto(t,b)]||c[1]||"-"||d[3:0] 
end
```
[Try it online!](https://tio.run/##bU/NasMwDL7nKYIvdZgHdjoYCfRJQg@OrRTDYgdZ3hjk3Vurp0Kqwyeh7wcpuBTv9w2TA18Q2kVaNSunfNcgUMHY2smM5qNslCSNl5NNEMpJ2e667/MLpWbeuMlUFJ9i3/10HvW1bSD6l/zVhii7pq31h4FALlK4hClaocRvwJJr95DBZqhTr80guoN@3QoBVt56HxyFFOuc/6PHtLLNDN/6jc0zd0s/S21Lic/8/ijkU2YGx2D689dBQgiclQlDvLESwRJvBq2fgfz1Aw "Icon – Try It Online")
[Answer]
# perl -anE, 65 bytes
```
s/[aeiou]\K\w+// for@F[0,1];$F[2]=~s/.\K.*//;$F[3]=~s/../-/;say@F
```
[Answer]
# [Zsh](https://www.zsh.org/), 41 bytes
```
<<<${(Mj::)@[1,2]#*[aeiou]}${3[1]}-${4:2}
```
[Try it online!](https://tio.run/##FcoxCsMgFADQPaf4UActDUTboRGHXqAnEAeJBi1EQZNAIp7dtvN7Z3ZtxgQ3IQQq@P3hnLwkvTF1uUptfdxUReUuqao9Kg/OaiNdN8MUUwwadp@2DMZnq7MFNtDxZ8kdq1uc1bsNoI3x0@pjgHwEk@Lyb8OzfQE "Zsh – Try It Online")
Normally `${param#pattern}` is prefix removal, adding the `(M)` flag keeps the prefix instead.
```
<<<${(Mj::)@[1,2]#*[aeiou]}${3[1]}-${4:2}
   ${      @[1,2]         }                 # first two args
   ${(M   )      #*[aeiou]}                 # match shortest prefix ending with a vowel
   ${( j::)               }                 # join the resulting words on empty string
                           ${3[1]}          # third param, first char
                                   ${4:2}   # fourth param, starting at third char
```
If the first two words can be given as a single space seperated argument (as in `corona virus` `disease` `2019`), then one byte can be saved for **40 bytes**:
```
<<<${(Mj::)${=1}#*[aeiou]}${2[1]}-${3:2}
```
[Try it online!](https://tio.run/##FcrRCoMgFADQ977iwgQ1GKR72cR9wr4gepA0vIMUtIImfruj53N@2beFcda01qSwz1cpTspb1Fs/GodxnyopchRTvZPyULI23nUL0DmmGAwcmPZMwWJ2JjuQg3hdmvy5@dU7c7gAxlqcN4yBQj6DTXG94vBsfw "Zsh – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 48 bytes
```
->a,b,c,d{a[r=/.*?[aeiou]/]+b[r]+c[0]+?-+d[2,2]}
```
[Try it online!](https://tio.run/##DcxBbsMgEEbhPaf4F13FToJppcqLJAehKBrDOEVyIBqgVVTl7K7373vSpuc6n77W/Zn6qfd9@CMrp@Nhd7HEMTd3dN1kxXXeatdd9l2wpjfutf5@x4Vx41oU8Gi1YLa7t@uhPJZYneIUVp8lJ8JPlFYQYmEqDKOHUfl83wgLKIToa8wJ5ZmC5DtjGD/1FoRtnpcZc0ubMVoRJoInDOb9Q1VhRqkS0w1emCpj1Fr/Aw "Ruby – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~44~~ 40 bytes
Original (and more fun): `{t←{⍵↑⍨⊃⍸⍵∊'aeiou'} ⋄ ,/⍎¨'tt12',¨' ↑↓',¨⍵}`  
Improved: `{d←2∘↓⋄t←{⍵↑⍨⊃⍸⍵∊'aeiou'}⋄,/⍎¨'tt⊃d',¨⍵}`
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz//1Hf1EdtE6pLQMSj3q2P2iY@6l3xqKv5Ue8OELejSz0xNTO/VL32UXeLjv6j3r5DK9RLSgyN1HWADAUFkPq2ySAOUHUt0LD//9XV1cvzi1KAlAJOpqGlroUJkAYA)1
Takes input of form: `'''word''' '''word''' '''word''' '''dd-dd'''`
This one is just a lot of fun and rather unconventional. Not necessarily the shortest, but that's the price of fun! Have a feeling `t` function can be further golfed but haven't managed to. The rest I'll leave as is because it's primarily neat; concision is secondary for once. Plus, who could possibly stomach messing with *42* bytes!
I'll add the full explanation tomorrow, however in short it's all just an abuse of the fact that we were trusted to determine the input format. Thus, one can pass it to the function as data and prepend (with a couple zips) the necessary manipulations, before evaluating the pieces of the list. This requires taking strings of strings as input; In *Dyalog APL*, quotes are escaped by doubling them, so printing `'''Hello world'''` yields `'Hello world'`.
Before each element is evaluated and concatenated: `{'tt12',¨' ↑↓',¨⍵}` yields `t 'corona' , t 'virus' , 1↑'disease' , 2↓'20-19'`. The two strings in the function are zipped together with the input to yield a piece of code containing the manipulations we desire for each piece. To clarify, `t` is the function which takes a string and returns the first elements until a vowel is spotted. The function `t` is defined in the right half of the code.
  
1Due to the dangerous 'execute' (`⍎`) operator, I've only gotten it to run online in TIO under [dzaima's](https://www.github.com/dzaima) dialect, which is the TIO page linked above. However, as long it's downloaded, it'll work in any old flavor of Dyalog, so I'm insisting on marking it as such in the title!
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 44 bytes
```
{S:g/<[aeiou]><(.*?\s//}o{S/\S<(\S*\s\d./-/}
```
[Try it online!](https://tio.run/##DcxBDoIwEEDRPaeYlSEkUkCjwaAeokvrYmxH0gQ6pKUmhHD2yv6/P5EfLmlc4PCFe1rlrRfdC8lyfD@6vCyeKgix8SqFkl2uZKGCMqU4ii0FXKDc2Zc9DNZRSJo9O4Sf9TGAsYEwEDRV3WaaxynO5AGNsXq27CAszngeCer2Wu2BIeh52HfR7aapMoQPgkaom9P5Dw "Perl 6 – Try It Online")
Combination of two substitution regexes, the first to replace the third word and year with the letter dash date, and the second to remove anything between a vowel and a space (removing the space as well).
[Answer]
# [Erlang (escript)](http://erlang.org/doc/man/escript.html), 124 bytes
```
f(A,B,C,D)->g(A)++g(B)++[hd(C)]++"-"++string:slice(D,2).
g([H|T])->case"aeiou"==("aeiou"--[H])of true->[H]++[g(T)];_->H end.
```
[Try it online!](https://tio.run/##ZU67bsMwDNz9FYYmEpIMN1tSxEAegz8gm2EUgkwrBFypkOR26b@7MtqtHMg74u5IiovxTlOykT/yVm0zXNRV3dQddefgglI6uJY@PCe44Sil0ELKlCN7d0oLW4K7OmBTORj678dYbNYkEoY4rOJ8hj@k9dCPGOY6x5V0V0jJdPDA8fVNd31Nfmq2d8Mehj2jqktxOM1fkTPBDMKGGLwRSnxyXFOZEyfaLylxaF@OAlEVvV8A1X9zjrQLf98uwEYyed8c27Yt1mb7AQ "Erlang (escript) – Try It Online")
## Explanation
```
f(A,B,C,D)->g(A)++g(B)                                            % Slice things up to vowels for A and B
                      ++[hd(C)]                          % Add the head of C
                                        ++"-"++string:slice(D,2). % Add a - and tail of D
g([H|T])-> % Recursive function for the vowel slicing
case"aeiou"==("aeiou"--[H])of true-> % If head isn't vowel:
[H]++[g(T)];                         % Return head + slicing (tail)
_->H end.                            % Else: return head
```
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 26 bytes
```
⭆Ｅ²Ｓ…ι⌊ΦＥaeiou⊕⌕ιλλ§Ｓ⁰-✂Ｓ²
```
[Try it online!](https://tio.run/##XY3BCsIwDIbvPkXoqYUO5m7iSQbCDgNhT1Da4AJdO7p26NPX1YGihyQ/yffn16MK2iub8y2Qi3yI27j3aualGgmdm1Pct1wICe1TW2xHP3OS0JOjKU38SjZieFuYQvKJFaMOOKGLaLa7M4W3orwoXYjzYU@8xM4ZfPCfIAn1l2AV@@jBksZ/ttnYnLUP3ilYKaQFDC2oFoSmPp5ytdoX "Charcoal – Try It Online") Link is to verbose version of code. Takes lowercase words either space or newline-separated. Explanation:
```
⭆Ｅ²Ｓ
```
For the first two words...
```
…ι⌊ΦＥaeiou⊕⌕ιλλ
```
... find the positions of the vowels, and take the minimum of those that exist, and truncate the word after that point.
```
§Ｓ⁰
```
Print the first letter of the third word.
```
-
```
Print a `-`.
```
✂Ｓ²
```
Input the year as a string and print the last two digits.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 55 bytes
```
1(UI#v´yXiн?}Tи`žMvykˆ}¯ʒ2+≠}WD.ïiŠŠs>£?}X>U}"-"?UR2£R?
```
[Try it online!](https://tio.run/##AWgAl/8wNWFiMWX//zEoVUkjdsK0eVhp0L0/fVTQuGDFvk12eWvLhn3Cr8qSMiviiaB9V0Quw69pxaDFoHM@wqM/fVg@VX0iLSI/VVIywqNSP///Y29yb25hIHZpcnVzIGRpc2Vhc2UgMjAxOQ "05AB1E (legacy) – Try It Online")
I'm sure this can be optimized in so many different ways, but I'll throw it in here anyway.
[Answer]
# [R](https://www.r-project.org/), 106 bytes
```
function(a,b,c,y,s=substr,f=function(x)s(x,1,regexpr("[aeiou]",x)))paste0(f(a),f(b),s(c,1,1),"-",s(y,3,4))
```
[Try it online!](https://tio.run/##PY1BisMwDEX3PYZXFqjgtDOLLnKS0oXiUYIh2MFSinP6jJJCNxJf76Ff96nfxzVHTSV7wgEjbii9rINoxbH/sgbiG3ZYeeK2VO@exKmsL4cNABYS5eBHT4CjHwDFR5M7QHd1Fja84w/APnmnSoNDF0ltasns8Ba6X7gcrLJFZ9UpT4dUmdQujxDCKbAsHBPN82Z0Kcr5@DJTI03v89OtO8VYaslk7J3qKrb/kjDJp@wB@z8 "R – Try It Online")
Say hello to R's atrocious handling of strings. I wouldn't be surprised if this could be golfed significantly.
[Answer]
# [Red](http://www.red-lang.org), ~~94~~ 92 bytes
```
func[a b c d][g: func[t][head clear find/tail t
charset"aoeiu"]rejoin[g a g b c/1"-"at d 3]]
```
[Try it online!](https://tio.run/##PU47bsMwDN19CkJ7EdspUDjH6CpoYERKVuFIAUUH6OldyUW78PM@5BOm45PJuiHcjrBnbxHu4IGcjTc4AXV2ZSTwG6NASJkuimkDHfyKUlkNFk67ccJfJWUbASH2I5fJvBlUILg6d4QijH6F/wcAdgDji5SMBswryV5bp1QZK7dpHqfFnJLHc1eWBiFR8ppKbnP9ziTl0ZXT8jH@KqmvsWyhtZb@vDKfXP9x78X3Ms3X946qcHdUlZRjJ1tI7cgyjs3mwD4bo2AD/OV2xw8 "Red – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 64 bytes
```
(a,[b],c)=>a.map(x=>/.*?[aeiou]/.exec(x)).join``+b+'-'+c[2]+c[3]
```
[Try it online!](https://tio.run/##bc/BioMwEAbg@z6F5FJdjUYtFA92H0SEjkmUFM1IouI@vWtaCqVuDiEM/3z8ucMClhs1TlSjkFtbbj5EVVNHPCivEA8w@mt5TeLvnwqkwrlOYrlK7q9BEN9R6dstbMITPYW8yur9yuuNo7bYy7jHzm/9inA0qIFEZFFmtqSOiFBWgpX7KGNpQbznCQIvSTyOixI0Lb6OzDDOkzT7Fgih@KRQO8z@amFwcFpaXBh5MWDphf2jCJfssG/dcjvrR4uMvVp8lOmwpdmRcd9pwAncPdMsP38A7ww0wGl@PiiTka6MnYzS3QMzEiY3Khh7a/RU9rRLcsrY9gc "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
εžMySkd0šÅ¡н}Iн'-I¦¦)S
```
Inputs as `["corona","virus"]`, `disease`, and `2019`.  
Output as a list of characters.
[Try it online](https://tio.run/##AUkAtv9vc2FiaWX//861xb5NeVNrZDDFocOFwqHQvX1J0L0nLUnCpsKmKVP/Sv9bImNvcm9uYSIsInZpcnVzIl0KZGlzZWFzZQoyMDE5) or [verify all test cases](https://tio.run/##LU29CsIwEN59CskiQoS0ClKXzgriIIoiBdMmLUFNJEmFDo4@iItvoJsOFVfxjeqlunzffT93pwyNBa8OaCj3uTWDJgoL3ECT3IKs1Xo@a1fv6@sxLqYbRl7n56k8f@7Hxefe6izLS3lpT6sRLm9htVqhRGklKcLoIHRugJkwnBqOsE@8IMJNV9nBba4hpIyJxAolYTaFZFrtoOkFffJvMpAoU9sUKM2lu@L/MvcjdpAAeH63V7tWc7dhrBYyc6Hm1IITEEKi6As). (Feel free to remove the `J`oin in the footer to see the actual output-list.)
**Explanation:**
```
ε                      # Map over the first (implicit) input-list of strings:
 žM                    #  Push the vowel constant "aeiou"
   y                   #  Push the current word we're mapping over
    S                  #  Convert it to a list of characters
                       #   i.e. "virus" → ["v","i","r","u","s"]
     k                 #  Get the index of each character in the string (-1 if not found)
                       #   → [-1,2,-1,4,-1]
      d                #  Check for each index if it's non-negative (>= 0)
                       #   → [0,1,0,1,0]
       0š              #  Prepend a 0 to this list
                       #   → [0,0,1,0,1,0]
         Å¡            #  Split the string we're mapping over on the truthy indices
                       #   → ["vi","ru","s"]
           н           #  And only leave the first part
                       #   → "vi"
            }I         # After the map: push the second input-string
              н        # Pop and push just its first letter
                       #  i.e. "disease" → "d"
               '-     '# Push a literal "-"
                 I     # Push the third input-integer
                  ¦¦   # Remove its first two digits
                       #  i.e. 2019 → 19
                    )  # Wrap all values on the stack into a list
                       #  → [[["c","o"],["v","i"]],"d","-","19"]
                     S # And convert it to a flattened list of characters
                       #  → ["c","o","v","i","d","-","1","9"]
                       # (after which it is output implicitly as result)
```
[Answer]
# [ssed -R](https://launchpad.net/ssed/), 70 bytes
Expects input through stdin in lowercase separated by spaces, e.g., `corona virus disease 2019`.
```
s_(.+?(?![aeiou])).*? (.+?(?![aeiou])).*? (.).*? \d\d(\d\d)_\1\2\3-\4_
```
`ssed`, known as "super sed", has PCRE which gives us non-greedy matchers.
```
(.+?(?![aeiou])).*?<space>
                ^^^^^^^^^^: Eats the rest of the word before the space
    ^^^^^^^^^^^: Before a character that is a vowel
 ^^^: Match fewest number of characters
```
The rest is simple enough once you understand the above. If anyone is interested I can go into more depth but I think this is enough.
The try-it-online thing doesn't have `ssed` installed in Bash. To try it locally you can install `ssed` through Homebrew by `brew install ssed` if you're on a mac. If anyone knows a way to get a working try-it-online I'll add it.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 96 bytes
```
#define z write(1,*a++,strcspn(*a,"aeiou")+1)
f(a,y)char**a;{z;z;printf("%c-%.2d\n",**a,y%100);}
```
*-13 bytes and all concerns resolved thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!*
[Try it online!](https://tio.run/##XZPbbqMwEEDf@QqLKhIGt@WSpI3c/ZI0D17bpJYSOzKQikR8e3YAt5sJ0gCe4xmOMcjnvZS325PStbGaXMi3N61OCpaKLGNN62VzskkqWCy0cV1Ms4JGdSJYT@WX8Gkq@PXCL/zkjW3rJF7I58VLqT5tzICxflHkOeXDDTp1siXGnro2ukYEjrGepGJb7fg0hgak59HAo@gojE3o/TxZbHfkD4ml886KmN@R8occobf2iFU/TGmUX8553Gg1J1uv8eT1nD@4M8qfg9LZ@K5BIBgJpYxsjbMIBqW9O9QoH5T@IqdzcILXZ@wekWDVmiOyUsFKmUaLBqPg1fRWefdQFrTqDtmqYCWRlQpW0mvR4jbBSn65g/Zj0cTud38@N@O8ic2bPN1dZcHgtTJYxMBImRebgd3TEiiEKoEWm7cc0woohKqm2vKBLoFCqOVYW1ZLTFdAIdQK6CbPH2rXQCHUenru@yrQIayudj4ZP14DK885XD5IYy7a1cm8VPqKhtt8R2FWltHfZ/wis3sRjPwf9BR@iNs/ "C (gcc) – Try It Online")
[Answer]
# [dirt](https://github.com/0xB0C5/dirt), 38
```
([^,]*[aeiou]{[^,]*,})*.{[^,]*,..}'-..
```
Accepts a comma-separated list of strings and outputs the disease name.
e.g. `dirt disease.dirt -i "corona,virus,disease,2019"` prints `covid-19`.
## Explanation
```
(
 [^,]*      # match and output any number of non-comma characters
 [aeiou]    # match and output a vowel
 {          # with no output:
  [^,]*     # - match any number of non-comma characters
  ,         # - match a comma
 }
)*          # run the above any number of times.
.           # match and output 1 character.
{           # with no output:
 [^,]*      # - match any number of non-comma characters
 ,          # - match a comma
 ..         # - match 2 characters
}
'-          # output a hyphen
..          # match and output 2 characters
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `Ṫ`, 15 bytes
```
ƛA1ḟ›Ẏ;∑?h\-?2ȯ
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJ+4bmqIiwiIiwixptBMeG4n+KAuuG6jjviiJE/aFxcLT8yyK8iLCIiLCJbXCJjb3JvbmFcIixcInZpcnVzXCJdLFwiZGlzZWFzZVwiLFwiMjAxOVwiIC0+Y292aWQtMTlcbltcImNvbXB1dGVyXCIsXCJhZGRpY3Rpb25cIl0sXCJzeW5kcm9tZVwiLFwiMTk3MFwiIC0+Y29hcy03MFxuW1wiY29kZVwiLFwiZ29sZlwiXSxcImZ1blwiLFwiMjAyMFwiIC0+Y29nb2YtMjBcbltcImFcIixcImJhXCJdLFwiY2FcIixcIjEyMzRcIiAtPmFiYWMtMzRcbltcInRyZWVcIixcInN0cmluZ1wiXSxcImNyZWF0ZVwiLFwiOTAwMFwiIC0+dHJlc3RyaWMtMDBcbltcImxvdmVcIixcInRpbWVcIl0sXCJjaG9sZXJhXCIsXCIxOTg1XCIgLT5sb3RpYy04NSJd)
#### Explanation
```
ƛA1ḟ›Ẏ;∑?h\-?2ȯ  # Implicit input
ƛ     ;          # Apply to both of the first two words:
 A1ḟ             #  Index of the first vowel
    ›            #  Incremented to make 1-indexed
     Ẏ           #  That many characters from the start
       ∑         # Join into a string
        ?h       # First character of the last word
          \-     # Push a "-"
            ?2ȯ  # Last two characters of the year
                 # Implicit output of joined stack
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~128~~ ~~124~~ ~~122~~ 119 bytes
```
a,b,c,d=input().split()
def g(a):
 for i in a:
  if i in'aeiou':return a[:a.find(i)+1]
print(g(a)+g(b)+c[0]+'-'+d[2:])
```
[Try it online!](https://tio.run/##HYxLCsMgFAD3OcXbqZiGJF1VyEmCixc/6YOi4qfQ09u0q2EYmPSpzxjuveN4jGa0G4XUKhdTSS@6OFjn4eQo1AA@ZiCgAHgJkP8LQ0exMZVdbflKu8LJU7CchFz0kDKFyn8DefJDSLPPWrIbk3ZflRa9m5hjQHhTbgUsFYfFwTovjy8 "Python 3 – Try It Online")
Pretty new, probably overcomplicated.
edit 1: saved four bytes by moving a part from print() to function
edit 2: saved two more bytes thanks to @surculose-sputum
edit 3: another three bytes thanks to @surculose-sputum
[Answer]
# [FEU](https://github.com/TryItOnline/feu), 57 bytes
```
s/([^aeiou]+.).+,([^aeiou]+.).+,(.).+,\d+(\d\d)/\1\2\3-\4
```
[Try it online!](https://tio.run/##S0st/f@/WF8jOi4xNTO/NFZbT1NPWwedCyZjUrQ1YlJiUjT1YwxjjGKMdWNM/v9Pzi/Kz0vUKcssKi3WScksTk0sTtUxMjC0BAA "FEU – Try It Online")
]