Name your novel disease

Question

Introduction

The current coronavirus disease is officially named COVID-19, from the 3 words corona virus disease, and the year 2019. (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, 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 1

Python 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!

-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, 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!

Answer 2

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.

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 3

Retina 0.8.2, 26 bytes

\B.*¶\d.
-
([aeiou]).*¶
$1

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 4

Jelly,  18  17 bytes

ḣe€ØcM$ḢƊ€⁴Ḣ”-3⁵ṫ

A full program accepting arguments ['word1', 'word2'] 'word3' 'year' which prints the result.

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 5

Japt v2.0a0 -P, 15 bytes

®¯ÒZb\vÃpVÎ'-W¤

Saved a byte thanks to @Shaggy (s2 -> ¤)

Try it

®¯Ò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 6

Bash + Core utilities, 58 55 bytes

sed -E 's/([aeiou]).*/\1/;3s/\B.*/-/;4s/..//'|tr -d \\n

Try it online!

3 bytes shorter through the use of \B, thanks to user41805.

Accepts newline-delimited input on stdin.

Output on stdout.

Answer 7

Python 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!

Inputs the first two words in a tuple followed by the third word and then year as a string.

Answer 8

Perl 5 -p, 48 bytes

$p='(.*?[aeiou]).*? 'x2;s/$p(.).*(..)/$1$2$3-$4/

Try it online!

Basically, a straight forward regex to pick out the relevant parts and put them back together.

Answer 9

QuadS, 33 bytes^SBCS

Takes lowercase multi-line input.

∊('-',⍨⊃)¨@3⊢⍵
^.*?[aeiou]|\d.$
&

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 10

Python 3, 86 bytes

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!

Answer 11

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!

---

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!

Answer 12

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!

Answer 13

perl -anE, 65 bytes

s/[aeiou]\K\w+// for@F[0,1];$F[2]=~s/.\K.*//;$F[3]=~s/../-/;say@F

Answer 14

Zsh, 41 bytes

<<<${(Mj::)@[1,2]#*[aeiou]}${3[1]}-${4:2}

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!

Answer 15

Ruby, 48 bytes

->a,b,c,d{a[r=/.*?[aeiou]/]+b[r]+c[0]+?-+d[2,2]}

Try it online!

Answer 16

APL (Dyalog Unicode), 44 40 bytes

Original (and more fun): {t←{⍵↑⍨⊃⍸⍵∊'aeiou'} ⋄ ,/⍎¨'tt12',¨' ↑↓',¨⍵}

Improved: {d←2∘↓⋄t←{⍵↑⍨⊃⍸⍵∊'aeiou'}⋄,/⍎¨'tt⊃d',¨⍵}

Try it online!¹

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.

¹Due to the dangerous 'execute' (⍎) operator, I've only gotten it to run online in TIO under dzaima's 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 17

Perl 6, 44 bytes

{S:g/<[aeiou]><(.*?\s//}o{S/\S<(\S*\s\d./-/}

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 18

Erlang (escript), 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!

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 19

Charcoal, 26 bytes

⭆Ｅ²Ｓ…ι⌊ΦＥaeiou⊕⌕ιλλ§Ｓ⁰-✂Ｓ²

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 20

05AB1E, 55 bytes

1(UI#v´yXiн?}Tи`žMvykˆ}¯ʒ2+≠}WD.ïiŠŠs>£?}X>U}"-"?UR2£R?

Try it online!

I'm sure this can be optimized in so many different ways, but I'll throw it in here anyway.

Answer 21

R, 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!

Say hello to R's atrocious handling of strings. I wouldn't be surprised if this could be golfed significantly.

Answer 22

Red, 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!

Answer 23

JavaScript (Node.js), 64 bytes

(a,[b],c)=>a.map(x=>/.*?[aeiou]/.exec(x)).join``+b+'-'+c[2]+c[3]

Try it online!

Answer 24

05AB1E, 22 bytes

εžMySkd0šÅ¡н}Iн'-I¦¦)S

Inputs as ["corona","virus"], disease, and 2019.
Output as a list of characters.

Try it online or verify all test cases. (Feel free to remove the Join 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 25

ssed -R, 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 26

C (gcc), 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!

Try it online!

Answer 27

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 28

Vyxal Ṫ, 15 bytes

ƛA1ḟ›Ẏ;∑?h\-?2ȯ

Try it Online!

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 29

Python 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!

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 30

FEU, 57 bytes

s/([^aeiou]+.).+,([^aeiou]+.).+,(.).+,\d+(\d\d)/\1\2\3-\4

Try it online!