[Question]
  [
ùñßello all, I hope this finds you well.
There are 118 elements on the Periodic table at the moment, each one corresponds to the number of protons in an atom's nuclei.
Each element also has a 'symbol'. Hydrogen has 'H', Helium has 'He' and so on. I want to know about these!
### Challenge:
Given 1 string as input, output `true` if the string is present as a symbol on the periodic table. Output `false` if not.
The string is case sensitive. While `He` is a valid symbol, `he` is not.
For reference, here are the elements that are valid symbols for this challenge (from [wikipedia](https://en.wikipedia.org/wiki/File:Colour_18-col_PT_with_labels.png)):
[![enter image description here](https://i.stack.imgur.com/VTwhl.png)](https://i.stack.imgur.com/VTwhl.png)
That is, if the string is any one of the elements in this list, output 'true':
```
Ac,Ag,Al,Am,Ar,As,At,Au,Ba,B,Be,Bh,Bi,Bk,Br,Ca,Cd,C,Ce,Cf,Cl,Cn,Cm,Co,Cr,Cs,Cu,Ds,Db,Dy,Er,Es,Eu,Fm,Fl,F,Fe,Fr,Ga,Gd,Ge,H,He,Hg,Hf,Ho,Hs,I,In,Ir,K,Kr,La,Li,Lr,Lv,Lu,Md,Mg,Mn,Mt,Mo,Mc,N,Na,Nb,Nd,Ne,Ni,Nh,No,Np,O,Og,Os,Pb,P,Pa,Pd,Po,Pr,Pm,Pt,Pu,Ra,Rb,Re,Rf,Rg,Rh,Rn,Ru,S,Sb,Sc,Sm,Sg,Se,Si,Sn,Sr,Ta,Tb,Tc,Te,Th,Ts,Tl,Ti,Tm,W,U,V,Xe,Y,Yb,Zn,Zr
```
And, Alphabetically indexed:
```
Ac,Ag,Al,Am,Ar,As,At,Au,
B,Be,Ba,Bh,Bi,Bk,Br,
C,Ca,Cd,Ce,Cf,Cl,Cn,Cm,Co,Cr,Cs,Cu,
Db,Ds,Dy,
Er,Es,Eu,
F,Fe,Fm,Fl,Fr,
Ga,Gd,Ge,
H,He,Hg,Hf,Ho,Hs,
I,In,Ir,
K,Kr,
La,Li,Lr,Lu,Lv,
Mc,Md,Mg,Mn,Mo,Mt,
N,Na,Nb,Nd,Ne,Ni,Nh,No,Np,
O,Og,Os,
P,Pa,Pb,Pd,Pm,Po,Pr,Pt,Pu,
Ra,Rb,Re,Rf,Rg,Rh,Rn,Ru,
S,Sb,Sc,Se,Sg,Si,Sn,Sm,Sr,
Ta,Tb,Tc,Te,Th,Ti,Tm,Tl,Ts,
U,
V,
W,
Xe,
Y,Yb,
Zn,Zr
```
This is a classic code golf, so be sure to reduce the number of bytes you use in any way possible.
Good luck~!
  
[Answer]
# [Factor](https://factorcode.org) + `periodic-table`, ~~22~~ 17 bytes
```
[ elements key? ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70sLTG5JL9owU3z0GBPP3crhYLUosz8lMxk3ZLEpJxUhYKi1JKSyoKizLwShezUorzUHIXE4uL85GIFay4upYhUpaWlJWm6FhujFVJzUnNT80qKgcoq7RViIeLLkhNzchT0IJwFCyA0AA)
Factor has a built in periodic table (with all 118 elements and no typos; I checked :D).
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~197~~ 195 bytes
```
^([HNOUVWY]|[CGLP]a|[DNPRSTY]b|[AMST]c|[CMNP][do]|Gd|[BCFGHNRSTX]e|[CHR]f|[AHMORS]g|[BNRT][ah]|[BLNST]i|Bk|[ACFT][lm]|Pm|Sm|[CIMRSZ]n|Ho|Np|[AELZ]r|[BCFIKPS]r?|[ACDEHOT]s|[AMP]t|[ACELPR]u|Lv|Dy)$
```
[Try it online!](https://tio.run/##HY7ZCsIwFETf@x0K@hViFxsxTUNS1zBi6462lbqAcP@93vo658wwzfF1rfK2P4h37XbghErni@Ua5IJYauTkQqWNzdYoyI0Tm2HPKFEa7lCD4gM5P5jEQrGzwpGZMDixKpLUWJwZK5PB5Ree9KXigSv5NxaCCcf3EqRLsiUXp4mxG1QkalIPFiK5QfOfn860RTPqSmEk0gzP7ovGq0siqQ3eJD8Ufoe9tg1yzxRe6qkf "Retina 0.8.2 ‚Äì Try It Online") Link includes test cases. Explanation: Grouping by last letter is slightly shorter than grouping by first letter. I also saved three bytes by handling Cd, Co, Md, Mo, Nd, No, Pd and Po together, Ba, Bh, Na, Nh, Ra, Rh, Ta and Th together, and Al, Am, Cl, Cm, Fl, Fm, Tl and Tm together. (Grouping by last letter didn't seem to offer the same opportunities.) Edit: Saved 2 bytes thanks to @DidierL by grouping B, Br, C, Cr, F, Fr, I, Ir, K, Kr, P, Pr, S and Sr together.
Edit: Added Be, which @JonathanAllen pointed out was missing from the table in the question.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 186 bytes
Returns `0` or `1`.
```
s=>parseInt("2cjns/5ogz/1r4hf/kafb8/1pszk/5vs1/1e/by01/5ywx//5m9t/3wh6q/nj4o/24hj/b8n5/21x5j//19b6u/65rh/bini/1/1/1/w/5/5yww".split`/`[([a,b,c]=Buffer(s),a-65)]||0,36)>>b&!(c|b<97|b>122)
```
[Try it online!](https://tio.run/##bcxPT8IwHMbxu@/CHUibDH50rJMlbol68uDFk4aQ0JZ2f5jtbAeDZe99gkdtntsneb41OzEnbNV2c232clLZ5LK8ZdbJV92hIBK1dkBNMQCxcangwBRfA2ndcAB6cgSIBH5ZEqCX/gxAv9IOVn2ZfIOuYwNRXNbA15pCRM60BiApT46QUFsCr3QF5Hc90FugDxaubapuB7sN2rCQh2KbPR@VkhY5HLJ5QvF2HJfhKsF5zmf3SIz8MX0YeU6iCE/CaGcauWhMgRQKmA0wvvuDT@8@tINHX4QHP272/@@7Mw@@Fb6m9ODn1aYf "JavaScript (Node.js) ‚Äì Try It Online")
[All truthy inputs](https://tio.run/##LZFLbtpQAEXnXQVlUEA6yYtJTJOqUNkOBBRwLNv9JFGk@Bn/CNjED4ckYgmVOumw3UfXkw10CZRW1ZWOrnSlOzmz4CFQYZktV3t5MY22cXerur1lUKpolK@a9XY4y5XQi@RZaOVRGou7IJbHQluq5zuhPyhNaJGQTwea0J/Wj0Loi5OVOFynnXuRz44K0T5KZ0Ie57poa4/6TAjtRHYq0dHLVMgsz4T2L2uh/z1Y1/fVcp6tbsXtdfM6QBLedM0qjqOyqVoEex29dbPZHHDYafV68s3rZriR70/ebmRPa7db27oRYiQYc4wFRomhMFYYFWaAiRlhppgZ5h1miRVgTbGwIqwYa46VYy2wCqzdqLAqThWnktMn@iV9Rb9isGAwZ8AgYlByFnA25SxiyHCHhGHMsGCoGDHKGZWcc14yDhhnjHflgXHFZMokYZIzWTEpmITY2AG2xJ5iR9gZdopdYC@54CLhQuFIHJwAZ4pT4JQ4C5wVToUb4ErcCDfGTXBT3By3wsOTeCHeAi/Bi/AyvByvxA/wJX6IH@Gn@Ap/jp/hL/jMRz7xJeKSS8lVzlX5X0mzTr31aj8uyn4Qpk1V6/ZqYZGrYh7tz4ukqajFO0e1D7XG71/fXn5837FRe1drvPz82mi1tn8A) / [Random falsy inputs](https://tio.run/##ZVJbbttGFP3XKib6qMn6hCPSphrHkQKStizDFk2ITNLEcJvhmzI5VGZIK06VHRToTz/bfXQ92UCX4I6MfAQNBnPnnnsuDg7u3BW7YzIR1bp7yts0e8gnD3IyXTMhs3PeaUMrWXFJ7bb4RE1xWOb0luXxM2qu5adbat9Jk5oZje9HJrXvNx8ptZujjh5syvEHyleHLbUOyxWNn3GbWuZHe0WpeRSPezq2RUnjilfUfDwbau8ENkNDruuqe0/fX2vXDDGSm4nb53kmNKmDPR3b@s12O8LBWJ9O4x@eaMk2fnH00zaempalPyQtlx1xyIQMnQROAaeG08ARcCScDk4Pl8GFm8Et4VZwb@EKeAxeCg9eBi@HV8Pj8Bp4LTxFSng9TiROYpzc41TgVOK0x6zBrMYMswwzgTOGsxRnGeaYq1BgnmPeYi5xjnOOc4ELXAhcMlxWuFTJHS57LFIsCiw4Fh0WLRYJfPgMfgw/hZ/Br@CX8Fv4a1zhqsCVRBAjQMAQpAhaBAJBg6BD0GPJsIyxzLDMsSywLLHkWPYIEcYIE4QNwgJhhrBCyBEKRAxRjChBlCEqEUlENaIKUYM3eIXX@DnDW7yN8Y7jnfj6OdoQQ/14MKizjrhq1Nc3CuSt0HYFrgqjY/W8IOZol@zv6@S3ASE7Uh6rJG0fMSFStYadqHhh5KJtvJIJT62gZhjGtbqOEOxeW7CuNATjadtouhIdGSZ5SUzynHzPHCnGUsyBfmM0bK1pvxJUOplM/9f7I7HGZJ@MbfILObAU1CryRNlW8HtRS9f1ne3PZFNWdaY5RsWTuk8zqTaSbLfE/bbw2Ooa616WCh0PPg9cQ43mlCUK75zsNrStM6NuC02C5DuRl2Tv33/@@PLXnyruKf97X/7@fU/XH/4D)
### Commented
```
s =>                    // s = input string
parseInt(               // parse as base-36:
  "2cjns/5ogz/.../5yww" //   lookup string
  .split`/`             //   turned into an array
  [(                    //
    [a, b, c] =         //   a, b, c = ASCII codes of the first
      Buffer(s),        //             three characters in s
    a - 65              //   use a - 65 as the lookup index
  )] || 0,              //   force to 0 if there's no entry
  36                    //
) >> b &                // right-shift by b positions (mod 32)
!(                      // test the least significant bit
  c |                   // make sure that s has either 1 or 2 chars.
  b < 97 | b > 122      // and that the 2nd one (if present) is a
)                       // lowercase letter
```
[Answer]
# Wolfram Language (Mathematica), 50 bytes
```
#~ElementData~"Abbreviation"&~Array~118~MemberQ~#&
```
Uses the inevitable builtin. Don't try it online, since it requires access to Mathematica's data repository that TIO doesn't have :( On the plus side, all of the nested argument precedences worked out so that the `~` syntax could be used without brackets.
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~98.5~~ 97.5 bytes (195 nibbles)
*Edit: -2 nibbles by changing the encoding*
```
?+! |_\$u .`/~`=`D-28\$N |+$\$! ~.@:@\$a $ 1e0ffdd0810caa7a28e383c93c330770433251ee362b67eb4b57b2c6f2899d4742d379353a3791767afb7dd86bbf684e52506db285eb7e59af343e632802eec0bde3135659c1618936c003d96bbca
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LY9BSkMxEECvkn6yK22TmSQzEcQKrr2AEX8mmYAgbvTvSi_iphsRPIlX8DYW7OrBg7d4H1-vzyIv-nY6fS7vY8O_PzfrlTk8FbuY7bw7ztfz3Qa42HtzWNtiV-a43V_ti63GGq9ujN4de9dqpQqsyNgyNkRH5AIiRK-KCSSRSpBIAi0N4Jx7oAAdKWPEeoanRHUI9c5JZCQOGiG61AU4qpDGXAcG1ITADlSbk67oMaaYm0-eM6bmHPZ87lv9_7lsfT9MZbpdyjQ9Xswf)
Similar 'build the element symbols using the lists of second letters for each first letter' approach to [Neil's Charcoal answer](https://codegolf.stackexchange.com/a/264726/95126).
**How?** (original 98.5-byte version):
```
?++! `%`D-26"j" |@\$u ~.$%:_$~ $ 
   !                                # zip together
       `D-26                        #  the hex data 243d...
                                    #  decoded using base 26 to " abc...y"
     `%     "j"                     #  and split on the letter "j"
                                    # with
                |@\$u               #  uppercase letters
                                    #  (printable ASCII filtered for uppercase)
                      ~             # by
                       .$           #  mapping over each group of lowercase letters
                          :_$       #  appending each to the uppercase letter 
                         %   ~      #  and removing spaces
 ++                                 # flatten to a list of element-strings
?                              $    # and find the index of the input
                                    # (or zero if not found)
```
[Answer]
# [R](https://www.r-project.org/) >=4.1, ~~235 232 224 221~~ 220 bytes
We build all valid element names by "overloading" the `/` operator with the function `strsplit`, then unpacking the string of single-character names. We unpack another string with all capital letters except J and Q, then paste them to the unpacked second characters of the two-character names.
I am sure it's very golfable because I am bad at this.
*edit: realized I can remove `UVW` from singletons.*  
*edit2: -8 bytes due to Giuseppe tricks*  
*edit3: `mapply` can be drop-in replaced with its simplified wrapper `Map`, thanks again Giuseppe*
*edit4: another -1 byte from Giuseppe indexing trick*
```
\(x,`/`=strsplit)x%in%unlist(c('BCFHIKNOPSY'/'',Map(paste0,LETTERS[-17][-10],el('cglmrstu,eahikr,adeflnmorsu,bsy,rsu,emlr,ade,egfos,nr,r,airuv,cdgnot,abdeihop,gs,abdmortu,abefghnu,bceginmr,abcehimls,,,,e,b,nr'/',')/'')))
```
[Attempt this Online](https://ato.pxeger.com/run?1=bZPdbpswGIYPdpariCJVgOSs3dF2sB4sNIQsgTDs_aRbtQIxPyp_wqZqrmUnaaVdy65h0y5m9oumSRMcPCHYfr7X5uPbY3d6Si-_9zKdv_r5-4v5QG7Pby-F7ERbFtJ6OCvqs74uCyHNxDQWtuOuN_4uoHvj3DCIF7VmGwnJL8h2ydgypJ_nL17eKFzcEF6aRpKVVSdkT3iUF3cdiQ48Leuq6URPYnEk-pdXJQYIz9JGkLoj6m_R9fckOWR1I0kUH3iRNy3JhL5Xq5Uwinma5bXSJDwr6kqtUXd5UZWCqIuTWJlUSGJYKqllWcMefz37IbmQX0VfSD59PZ8m5mwxI9OZreFouBprjY2Gr7HTCDSoxnuNDwqT6X_X7KMe2mu8ScAMLMEK7EABSrDXXPBR4SLCYA4W4B0IjY1R-wByMAVR0K5HlTZy2A04aJDGRo6rGMSTq6PmEnOWeLLsR5UOajsQO6jtYNEK-VbIt8IcdyCOxUVWtxlVuqi3rkHINuAWyi2OYjs8Qe7tvaaXjMo8JPBQ1YPSw_Y9vAAfSh8b9zHTR0ofRfx8VOlD4LfoD4h3SBxAFkAWQBbgWALMD5A4kKPKABsJIQghCJEjxDmFKBKiE0LsIcR8Go_KKPqPQkCxlGI7FEspMlGkYSjIUJBhFRvvRYbaDBoGAcO7Ztj4J5TaQ3M93nnXQ-9jhgYapWlwMs-xGrfvNN7OrMmkK7kporYtj-a_75ZM07_f8-k0_P4B)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 158 bytes
```
->s{i=[*?B..?Z,*'Aa'..'Zr'].index(s)||2;",:wyp;S_F&?{}?z_o?sqo}]}wo?sg~<?2>~w}SZ|CooOj9Q_o?;"[i/7].ord[i%7]<1}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=TZLLbtNQFEXFNBNmSDDBCgK31aoRnRRoU8t2m6Zq4hjbPJoqquzYSQx-BN-Y0ibp_RAkVCH4CD4FvgarBYk9OGdrn8mR1v7yvazCi-tv49aPaj7efP7r6-aeWCSt0w3d1DR9wIZqBKqmqYNSHWpJHsWf18T6crm10-TBvZfnF7Md70y27z7RpVyspH559rDQhZTyY7GScihvtTqvw8nVrr61dyXP5cqTg2UdP7SKov_-hXx1_0z-p0JK_cbsNE-Tp9tDrSij0-Tx9nD32er2y993fsZpnAmlpajGCGOCkWJkGCWGwJhjVJgBJmaMOcVMMD9gllgBVoSFFWONsVKsHCvDKrDqo8Cq2Bfsh-xfcFByIDioaGe0U9q0Y9olhwGHEYcxHTr1mNAZ0ynoCI44yjkqOea4pBvQTejW5hPdil5Eb0IvpzenV9AbYWMH2CF2hB1jJ9hT7AJ7Rp_-hL7ACXFwApwIp8ApcTKcOU6FG-CGuDHuGHeCO8XNcSs8vBBvhJfhTfBivAQvxyvxA_wQf4Qf40_xBX6Kn-BnvOU1b3gXc8JJyCCnJq2JWZrM11TU9UZj7V8DLtV1LQtmykJZimVDUcogEbHSbAdJGkfKo4VYNZUqT2MhlPGpGCqtlnJDqa7NKK2iWK-b0_hL8Pr6dv8B)
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 99 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
¬ª·πò·∫ã·∏Ñ√¶√òo·πñ√üYp‚Äô…≤¬ª13BkAd√óJ‚ÄúU·∫π√êƒã·∏∑·πòt∆ÅM∆ì·∫†√á|hu·πó¬Ω√±{…ì[·πá·∫ä¬ß ?bx‚Ç¨≈ªcb0·∏≥√ü∆ù·∏Ñ∆§ƒ∞·ªµ·πÅ√ócj"D¬≥¬ø≈í_…º·ª¥ƒ±R9?√±‚Äô√û@YX¬ß1O√ßG¬¶ Ç≈ª‚ÄúZ‚Ç¨Jw∆á
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSVDMiVCQiVFMSVCOSU5OCVFMSVCQSU4QiVFMSVCOCU4NCVDMyVBNiVDMyU5OG8lRTElQjklOTYlQzMlOUZZcCVFMiU4MCU5OSVDOSVCMiVDMiVCQjEzQmtBZCVDMyU5N0olRTIlODAlOUNVJUUxJUJBJUI5JUMzJTkwJUM0JThCJUUxJUI4JUI3JUUxJUI5JTk4dCVDNiU4MU0lQzYlOTMlRTElQkElQTAlQzMlODclN0NodSVFMSVCOSU5NyVDMiVCRCVDMyVCMSU3QiVDOSU5MyU1QiVFMSVCOSU4NyVFMSVCQSU4QSVDMiVBNyUyMCUzRmJ4JUUyJTgyJUFDJUM1JUJCY2IwJUUxJUI4JUIzJUMzJTlGJUM2JTlEJUUxJUI4JTg0JUM2JUE0JUM0JUIwJUUxJUJCJUI1JUUxJUI5JTgxJUMzJTk3Y2olMjJEJUMyJUIzJUMyJUJGJUM1JTkyXyVDOSVCQyVFMSVCQiVCNCVDNCVCMVI5JTNGJUMzJUIxJUUyJTgwJTk5JUMzJTlFJTQwWVglQzIlQTcxTyVDMyVBN0clQzIlQTYlQ0ElODIlQzUlQkIlRTIlODAlOUNaJUUyJTgyJUFDSnclQzYlODcmZm9vdGVyPSZpbnB1dD1CZSZmbGFncz0=)
Inspired by Neil's Charcoal answer.
#### Explanation
The idea is to construct the first and second letter strings separately, and then zip them together. We can sort the first letters in alphabetical order, and then multiply the alphabet with a list of numbers to get the whole string. There are 8 `A`s, 7 `B`s, 12 `C`s, etc. So, we use the list `[8, 7, 12, ...]`. Then, we use base-255 compression to get the string of second letters, replacing it with a space where the symbol is only one letter, then after zipping we can remove the whitespace. Finally, after we've constructed the list, we can check if it contains the input.
```
¬ª...¬ª13BkAd√óJ‚Äú...‚ÄúZ‚Ç¨Jw∆á  # Implicit input
¬ª...¬ª13B                 # Compressed list [8,7,12,3,3,5,3,6,3,0,2,5,6,9,3,9,0,8,9,9,1,1,1,1,2,2]
        kAd√óJ  ¬†         # Multiply elementwise with the uppercase alphabet - the first letters
             ‚Äú...‚Äú       # Compressed string of second letters, or spaces where N/A
                  Z‚Ç¨J    # Zip with the first letters and join each pair into a string
                     w   # Remove whitespace (the space fillers in the second letters)
                      ∆á  # Is the input in this list?
                         # Implicit output
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~¬†222 219¬†~~ 212 bytes
-3 thanks to [bsoelch](https://codegolf.stackexchange.com/users/118682/bsoelch)! (Avoiding `enumerate`.)  
-7 thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor)! (Use the direct functional reference `[...].count`.)
```
[chr(i+65)+r[r>'y':]for i in range(26)for r in'cglmrstu,zaehikr,zadeflnmorsu,bsy,rsu,zelmr,ade,zefgos,znr,,zr,airuv,cdgnot,zabdehiop,zgs,zabdmortu,,abefghnu,zbcegimnr,abcehilms,z,z,z,e,zb,nr'.split(',')[i]].count
```
(Beryllium is included at a cost of 1 byte)
**[Try it online!](https://tio.run/##HYzNisMwDIRfJTfbVPSwZXtYaKHPkeYQO/4RTeQgOwvxy6dq0WFGI8237jVluhzh9jx6l1jj6fprTtzzXe3qbwiZO@yQOh4pev1zNZ9EMlIuzguXukEbfcIXi04@zLRkLhvYssNHm5cvkIu4EHOBRgzQJELe/sFNkXKVqp0EkldosXw3oQgaRiutRMKxzkdcpDyKSzgv8vcdIVsgVueyzli1AmV6HIazyxvVY2WkqoNWj6iMOd4 "Python 3 ‚Äì Try It Online")** Or see the [test-suite](https://tio.run/##bZJJb9swEIXv@RWqL7KRDzm0aA4BWkCW49hNrKiSumQ7aKEkIhJlkFIAO@hvdykjORQoCbwZzvLwyOF219ed@nQovzweHvJaT@Xp@efZqX7QX92de/FUdtqRjlSOTlUlph/PZ2PExpSbV02rTT@wT0Utn7W1hSgb1XbaDGRmx2j3wlZhM9Yrq86wVxr2NiT18EJeVKrrbWtWWJJuy74yx5NlsdSkme2qleXJclHJ1jan1qtl09q647bMGUq7Z2bbyH7q4s4e5NPTWd4Nqj@MckUjWqH68RoTL8er8Bq8Fk/jGbweb2CeMmcumNfMJfNn5ho/xS/w8QV@id/gK/wWv8O3SYM/sDAsMhY7LjWXhsuBZcuyYclSsNRcpVwVXAlWrCxUrEpWHSvDmrVirbnmWnOTciO5sc4LNwObgk3FRrHp2XRscgKClCAjKAgEgSSoCTqCLbfcVtwawoyQMCUsCDtCTdgS9oQDUUqUEQmikqgiqokU0UBMnBHnxC1xRSyIJbEi1iQpSUaSkwiSmsSQNCSSpOUXP/jJb8Eddxn3ins9eXv5CZPZxYljV2qM0L1TTt9efoZTTpapbETh9J0jCxuT5c55fct/0H9sj5Oq91FNTk7GwfXCHKc2dV0c91GN6IywGOHbCN9H8LIj5sL9V4D9WlbEyHJUsFZ5p7XI@2b3rkFaRa9jwf8kbLVU9lpe0xyVGGc78haT2eEv "Python 3 ‚Äì Try It Online").
Beatable with a hashing approach or even regex? (Edit or golfing [bsoelch](https://codegolf.stackexchange.com/a/264716/53748)'s ...until they golfed mine! ;p)
[Answer]
# [Python](https://www.python.org), 210 bytes
*-10 bytes, thanks to Jonathan Allan*   
*-11 bytes, thanks to xnor*  
```
lambda s:s in{*"BCFHIKNOPSUVWY"}or"A"<s<"["<s[1:]in[*"cglmrstu,aehikr,adeflnmorsu,bsy,rsu,emlr,ade,egfos,nr,,r,airuv,cdgnot,abdeihop,gs,badormtu,,abefghnu,bcmgeinr,abcehslim,,,,e,b,nr".split(",")[ord(s[0])-65]]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dZPRbpswFIYvdpensLhKuj9TU2nTFDWTgDRN14QgoO2SNBcGDFgFE9kQLar6JLupNG0PtLvtaeak7Vo2jQsff_7t38fG58v39bbKSnH_NRlcf6urpPv-54-cFmFMieorwsXtgWHZo_HZuTNz_YvLq7lxV0rDNI7VsbHU7bLXX3GxPDCiNC-kqmpQlvEbCRqzJBdFKVWNUG2xi6zI9wJYmpQKQgKauaw3iOJUlBVoGDOelWukCiGNS1loRz3KkjQT2igqUsb1OhpGLFM5L6A_hlB7GW_UOudV24DRWZYybqvl4arTffd2tXo42a9XVyxnBROVGhhmBDOFmcMsYEqYCmYFs4ZFYcFisDJYHNYNLAmbwo5hw2awE9g5bAG7gF3C1qKCXWOoMAwx3OJE4kThpMaowCjHCCOGkcQpxWmMU4YxxrpJMU4wLjFWOMOZwJnEOc4lJhQTjonubDCpMY0xTTEVmFaYlphGcOBQOCGcGA6Dw-FkcEo4a8wwSzFTcEO4cCncGG4JV8It4FZwa3gUXgiPwUvgpfAyeAJeDR9-CD-CX8BP4TP4HL6ALxFQBCGCCAFDkCFQCHIEHEGBK1zgEp8Y5piHWAgsGj-g1VpLLqp20tY3bXQ6zzhmDbRkA826gcNtAyebBs4btHjhZHS7XeOF1tyjSVEzoWGDPjYoaCZrNU-22FErKSWJerpyiKQiZe3Dz0nS6bcI2QtHz0K3hz8aIWoQZbId9Tqv9_GoQ3iip38YHBKWK0Ye1f1crehaIbvyJE8vmlARk6StHu0IeUzLSOhu-bpUvOIb1ifXxq26u9Y38mT1r83O_P9WgqX0L6uH-rq_f4i_AQ)
## Explanation
First check for one character element names.
If the name has two characters check if the first is between `A` and `[` (one after `Z`) in lexicographical order.
Then check if the second character is a second character of an element name starting with the first character
# [Python](https://www.python.org), 362 bytes
the naive approach
```
lambda s:s in"Ac,Ag,Al,Am,Ar,As,At,Au,Ba,B,Bh,Bi,Bk,Br,Ca,Cd,C,Ce,Cf,Cl,Cn,Cm,Co,Cr,Cs,Cu,Ds,Db,Dy,Er,Es,Eu,Fm,Fl,F,Fe,Fr,Ga,Gd,Ge,H,He,Hg,Hf,Ho,Hs,I,In,Ir,K,Kr,La,Li,Lr,Lv,Lu,Md,Mg,Mn,Mt,Mo,Mc,N,Na,Nb,Nd,Ne,Ni,Nh,No,Np,O,Og,Os,Pb,P,Pa,Pd,Po,Pr,Pm,Pt,Pu,Ra,Rb,Re,Rf,Rg,Rh,Rn,Ru,S,Sb,Sc,Sm,Sg,Se,Si,Sn,Sr,Ta,Tb,Tc,Te,Th,Ts,Tl,Ti,Tm,W,U,V,Xe,Y,Yb,Zn,Zr".split(",")
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VdDNqtNQEMBx3PoUl6xa-OtaBBcnp01TbpKGnOPVW9ycNJ-aj3JOcqFrH8NNQfSd9GksFIRsZubHDMMwP36fL1MzDtef1Ycvv-apevPu76uvnenzwjy49-6hHTxxQtSIDtEjLMIhJsSMb_DxG_wW_xu-RRpkgUSWyArZIQdkjxyRt6ZDzmwcm5zNha1l69jOBD1BR0BQElh2hl3BriQkvIWasCIcCR179gN7yyOPlsgQtUS34oVoJi6Ia-KBeCIeiU8kJIYkJylISpKWpCEZSc4cONQcHGlOSmpIC9KR1JL2pBPpTGbIcrKSrCKryRqygWxGoXLUCdWjalSJalEDyqINOkef0CW6QTt0h27RPZ_4yBOfS555zjkOHK331p27dlp5eOv7y_98P9t2mFbVygtLb71-_Z--XVDMC24uC0Yvy-Hl7EJ6ufd40_2U6_We_wE)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 100 bytes
```
‚Ä¢√ç√∏ŒªMI;√åL‚ÇÇ<√Ω¬§‚Ä¢13–≤AuS√óJ.‚Ä¢‚àä√óF√©√õ√ç@∆∂
‚Äú¬¨E|*[√≥AR{≈ì‚ÇÑ√ù√ë√¢W í$^C√ì%$m√öL‚ÄîŒªÀú√á√•√∞H%,YŒµ∆íBJ!¬ß¬ΩPŒ£v íR√æKŒ±‚ÇÇ‚ÇÅ√¢nŒîNŒ∏5¬®√ì‚Ä¢√∏‚Ç¨√°I√•
```
[Try it online!](https://tio.run/##AbMATP9vc2FiaWX//@KAosONw7jOu01JO8OMTOKCgjzDvcKk4oCiMTPQskF1U8OXSi7igKLiiIrDl0bDqcObw41AxrYK4oCcwqxFfCpbw7NBUnvFk@KChMOdw5HDolfKkiReQ8OTJSRtw5pM4oCUzrvLnMOHw6XDsEglLFnOtcaSQkohwqfCvVDOo3bKklLDvkvOseKCguKCgcOibs6UTs64NcKow5PigKLDuOKCrMOhScOl//9CZQ "05AB1E ‚Äì Try It Online")
Same as my Thunno 2 answer.
*-1 thanks to @KevinCruijssen*
#### Explanation
```
‚Ä¢...‚Ä¢13–≤AuS√óJ.‚Ä¢...‚Ä¢√∏‚Ç¨√°I√•  # Implicit input
‚Ä¢...‚Ä¢13–≤                  # Compressed list [8,7,12,3,3,5,3,6,3,0,2,5,6,9,3,9,0,8,9,9,1,1,1,1,2,2]
        AuS√óJ             # Multiply elementwise with the uppercase alphabet - the first letters
             .‚Ä¢...‚Ä¢       # Compressed string of second letters, or spaces where N/A
                   √∏      # Zip with the first letters and join each pair into a string
                    ‚Ç¨√°    # Remove whitespace (the space fillers in the second letters)
                      I√•  # Is the input in this list?
                          # Implicit output
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 120 bytes
```
‚Ññ‚ÅªÔº•‚Äù|¬´‚Üì‚Äπ‚ÑÖZy‚äó‚åà‚Üó‚Å∑‚óß‚ü¶œÄ@0\`‚ÄΩ‚óßÔΩûÔº®‚âï' tÔºü¬π6¬¥‚ÜóTÔºü‚ÖâœÇ6œÉ‚Äù‚Å∫Œπ¬ß‚Äù&‚åä‚Üß\`rfVÔΩû‚çòÔº≤ÔºØÔº¢;√º‚åà√™‚Üô‚åïÔº∏hk~& ‚ÑñÔº•‚™™Ôº§Ôº¥N¬øÔºØ-¬∑‚Å∂‚Äπ6n√ó‚äü3‚ú≥‚àßÔº°pÔΩúŒªÔº∏‚Öâœâ‚™´¬¶‚Åª‚äü¬ªlC‚Üì√óÔºõ!"B‚äò‚Öà√™Œ±‚äó‚ó®¬∑¬≤‚ÄùŒ∫jÔº≥
```
[Try it online!](https://tio.run/##TdDJboMwEAbgV0GcQKJP0FMSKEUJBTXpktwMOMYTL8hLlD69O6RB6nf4NR7Zo5H7kZheExFCa7hyyUZ7zJorb5OaTEm8elj/2fyT53lRFC@zsixf76qq2m53s/rubdE0Tbt4f9gvDouPz6/v4/F0irOoFbgCz6KVq9RAb0ncMyGNdZ7QkcPFkIGeQUiljfWd/cGkeJzb9MxAW1AGDOHGX/uBKe1IN8wP9cTAYg1SG5zV4eVR@a6njINUhmA1ciEtANAOZ@AmlzRNsyiGGLNSk3d7h3/FEmw/h7Cm4ekqfgE "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` for an element, nothing if not. Explanation:
```
‚Ññ                   Count of
                  Ôº≥ Input string in
   ‚Äù...‚Äù            Compressed string of first characters
  Ôº•                 Map over characters
         Œπ          Current character
        ‚Å∫           Concatenated with
           ‚Äù...‚Äù    Compressed string of second characters
          ¬ß         Indexed by
                Œ∫   Current index
 ‚Åª               j  Remove all `j`s from all strings
                    Implicitly print
```
The string of two-characters elements is 151 bytes compressed. I tried uppercasing the string which reduces it to only 127 bytes, with the decoding logic resulting in a 155 byte solution, but then I hit on the idea of compressing the first and last characters separately. I then saved a final two bytes by compressing the single-element names with a trailing `j` which I then remove afterwards.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~207 190~~  192 bytes
```
->n{k=!j=8
"&$&%$%&$$&amp;%$$%	'($($$$3'&amp;$%\*6&amp;$$)$$$&amp;$%44)@$%7\*$(6&amp;$G$$+'B'k6+,&$4$&*$(4$%$&$)$>/5$%,%&%$W$&$$$)\*4$%%%'$'6$$%&$&$)\xA5DS'".bytes{|i|k||=n==(j+=i>9?i-35:338).to_s(36).capitalize}
k}
```
[Try it online!](https://tio.run/##PY1La8JQEIXXza9oL2fuI9F0cZP4gButFLrswkWhrRQtEa4RFY2gNf72OAp2Nd85c@bMdj87NnPXtPPVqXRPC9cNhIQkkMR1gB6UhgZglQSFGduGFXOSmCGoE0Kz@QZEaqTKLGpJJJDsJiCOGeTPKahFXPbBms9D3hApqAzXN5z5Prykr2Ml4tmxKnan2tdlXbuVc3oROZ/3Br5t0761XRNX65@dtpmJf6cbX02X/q84B@W52TzOv8S7mAQ3GN9hVNzpc/1PWzFpLg "Ruby ‚Äì Try It Online")
For some reason, `TIO.run` pastes the `&` characters as `&amp;` in the output formatted for this website, but the code at `TIO.run` shows them as a single character.
Produces all valid elements by incrementing `j` according to each term in the magic string and converting the result to a base 36 number. The increment of `j` is based on `ASCII CODE - 35` to avoid having `"` or `#` in the string.
Single-letter elements are first in this order, and there is a big jump of 338 from `Y` to `Ac` which requires special handling as it won't fit in a single byte. The jump is encoded as a `TAB=ASCII 9`.
2 bytes added to make it work with `Be` and `S`
[Answer]
# [Python](https://www.python.org), 271 bytes
```
import re
re.findall("[A-Z][a-z]?","AcAgAlAmArAsAtAuBaBBhBiBkBrCaCdCCeCfClCnCmCoCrCsCuDsDbDyErEsEuFmFlFFeFrGaGdGeHHeHgHfHoHsIInIrKKrLaLiLrLvLuMdMgMnMtMoMcNNaNbNdNeNiNhNoNpOOgOsPbPPaPdPoPrPmPtPuRaRbReRfRgRhRnRuSSbScSmSgSeSiSnSrTaTbTcTeThTsTlTiTmWUVXeYYbZnZr").__contains__
```
[ATO](https://ato.pxeger.com/run?1=NdHPS8MwFAdwPLqr_0DpxQ02zyKopNm6jrVZaOKPbYyRtkkbbJORpMIc-0u8eNH_Sf8areLl8x7fw3vw3uvHbu8qrd7e3lsnRpdfJ2ey2WnjPMN7wrv-KRdCqoLVdd9fg9Fqs2ajl82tP_RBDkpQgwYYYIEDbcCCoApk8BQYyGABIYcC1lDBBmpooIXt2I6z8X5iJnbShk1YhyEPzZRNiymPIh6VkYh0ZGczNTPzuYlZLGMTP8dtUiRlohKX6CRHiKEMFYgjiSqk0W6xKBcWZxgzXGCNDW6ww23K0izlqUjLtEpV2hKSkZw0pCScSKKIoYxmNKecVtTSmkraPNzdP_LlMluplfEHF9ttrpVjUtnt9u82nxuhjee4dZ5UXt8HrT_0_Eh0wl9nv0HHogN1rFTn0h9c9U53RirXF-eHbsjRG914B9Hv-sHxfPC35P8R3w)
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 257 bytes
```
$args-cin("AcAgAlAmArAsAtAuBBaBeBhBiBkBrCCaCdCeCfClCnCmCoCrCsCuDbDsDyErEsEuFFeFmFlFrGaGdGeHHeHgHfHoHsIInIrKKrLaLiLrLuLvMcMdMgMnMoMtNNaNbNdNeNiNhNoNpOOgOsPbPPaPdPoPrPmPtPuRaRbReRfRgRhRnRuSSbScSmSgSeSiSnSrTaTbTcTeThTsTlTiTmUVWXeYYbZnZr"-csplit'([A-Z][a-z]?)')
```
[Try it online!](https://tio.run/##XZDtbptAEEV/w1MgCzW2FB4hqmFtjBXAK3ab1LasalmGjwRYuh9N29TP7pImcSr/nDP3npFmEE8gVQ1t63Eh4eSWN88nl8lKebzppxOf@5Xf@p0vfeVr3wQBCyCogyZ4DCRCDBUIUIla1KMOCSSRQmaRL9Ti11Iu1dKEIYRd2IZyxVbFCqIIoioqIxGp9bpfy9tbGbO4iWVs4h8JT4qkSvpEJDpNWZqnRQppk9apSIfNptoonGPMcIEFlrjDGpuMZXkGWZlVWZ31mSEkJ5x0pCJAGtITSRnNKadAa6poSxvafbm7/wrbbb7rd3LicTW0jb6a7n1vd9gz7/fh8@xqdjra9nxqW9fz8QNycu24WhqYvYLtxRzABWD/GiVr1TvpxQCX7O7@PzJz/jihkEvGa2@TPwDXzrNtuRqURkzBGISfw0ihcG4c99u4kqBMq8fpk1s656Bt7TFBRmnRvWoOznwUWcRwDkq9lM8iD747b5oxQUfDy/rDZGXvJ86po308/QU "PowerShell Core ‚Äì Try It Online")
A naive approach, `cin` stands for `case sensitive in` and `csplit` for `case sensitive split`.
+2 bytes for Beryllium
[Answer]
# [Python](https://www.python.org), 210 bytes
```
lambda s:1/(s in{*"BCFHIKNOPSUVWY"}or"A"<s*(s[1]in"cglmrstu,aehikr,adeflnmorsu,bsy,rsu,emlr,ade,egfos,nr,,r,airuv,cdgnot,abdeihop,gs,badormtu,,abefghnu,bcmgeinr,abcehslim,,,,e,b,nr".split(",")[ord(s[::2])-65]))
```
Many thanks to [bsoelch](https://codegolf.stackexchange.com/users/118682/bsoelch)'s [python answer](https://codegolf.stackexchange.com/a/264716/46901)!
I refactored it so it returns `1.0` if the input is an element and raises an Exception if it isn't.
Interesting notes:
1. The `*` is used as a boolean AND.
2. `s[::2]` produces every second element, and `ord` raises an Exception if its argument is longer than one character. So, this expression filters out anything 3 chars or longer
[Attempt This Online!](https://ato.pxeger.com/run?1=dVTLbuM2FN105a8g1I2dHLdJgBaF0RSQlDjOxFYESzPTZBIUlHQpESNRBikFMQbzJd0EKNpv6Hd0135NKdtJ7I7Lhahz7oO8ukf31z8Wy6ao1dNv4vTu97YRwx_-_qvkVZJxZkbH3_YNk-rTgeP548nlVXAdRm_fvb9xPtfacZ0fzUHffDi-l8pJ87LSpmnBqZAfNXhGolRVrU2LxCzR7VSVKwMoF7WB0oDFUrcPSLNc1Q14kpEs6gVyg4Rnta5sRsuSyAtlE6VVTtLG8SSlwpSygl2ExOZyvjGLUjZ9B87gQ60ze7HR6OR-MPz-u_vBYF3ZP1_9SSVVpBpz6rgp3BxuCbeCq-EauA3cFh6HB4_gFfAkvI_wNHwOP4MPn-AL-CV8Bb-CX8O3RgO_xZnBWYKzJc41zg3OW4wrjEuMMSaMNS44LjJcECaY2EeOicCkxsTgEpcKlxpXuNKYckwlpvblAdMWswyzHDOFWYNZjVmKAAFHkCDIEBACiaBAUCNY4BrXOa4NwgQhQo4wQ1gj1AgrhA3CFnOOeYI5YS4wzzEvMFeYt4gQJYhSRBWiHBEhkogUIo2YI04Qp4gJcYHYIC4RS8QV3uMt3uFnwg1uEtwq3O70oNezCmDcGNLNL_SY0qKRteqbwajH7CKta00ZO2WxbmlFNXq5tnVLWM8X8Oo85qVZewupeFluRXy90FLZszfOI-awg5fIQ4tEre3zkG0lluLZ4zVPtzQ1rVav59tD_-PApSHmrqqzZZ13SfrCoccFpY0976XgEbtzPpnPd073RTY3HA6HFq2B6FshOoMtOKEd6Okd6LY78Gy5A6cPO_BmB91uZdrcofdFf7p7fkm6-9mU_ofP9_Jne9k3e9lY76W9dC9929XS9Tc9tuPKdkfl1D_C0aMQK72tTCd7TYyZ07TQ_fR4cLjaTwadLNKTn45WfWcbY2-jFzumWDcT2fMkeRbGHqk_x-z4M66yVRbx8jMwtmmSIzp9M0U5b-QDbYlnPcCentb7vw)
[Answer]
# [C (GCC)](https://gcc.gnu.org), ~~276~~ 274 bytes
*-2 bytes thanks to [@ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)*
```
f(x,s,i,j)char*x,*s;{s="-cglmrstu-@aehikr-@adeflmnorsu-bsy-rsu-@elmr-ade-@efgos-@nr--@r-airuv-cdgnot-@abdehiop-@gs-@abdmortu--abefghnu-@bcegimnr-abcehilms-@-@-@-e-@b-nr";i=*x++-64;j=*x?:64;*x=i&&i<27&63<j&j<123&*x*x[1]<1;for(;*x=*x*i>0;)i-=*s++==45;for(;*s-45;)*x|=j==*s++;}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VVTbTttAFFTVJ_uxX7CkauRLViJAKcVxGxoIoU2MZbs3KKocx042xHbkdZAp5UfaF174qX5NzxhohZIzPt6dmXN2td7ft9H3aRTd3NyuyoTv_HnyLNGqlmyJ1lyPZmFhVC1DWlfSbvBoukgLWa54N4xn4ryg5yROFmmWF3LFx_KS49mNicVphrJkmkvezQrOuzQkitUFjybTLC9JOp6QSb7k3ams39K8IGsejkk1y8hnHMVTkZI4pGwmFinx6h85j3lWNCxhG5Vp8u0ta07Z211KjMoWzabobLxqbm925s15p72x2TQqozptn3XaVpIXGkg0It6sW7rgtiFN07a3Xt7PSU6pblQ_7bldz1nX91vz9NdzWq_IYhazdntHfXjLmBYzk73WVRU7xowylmUUylieZmfMZleq0tiLGq3G3hSwAKSAAiABJWBF8C4EIGLADCAA5wAIemD0JgAEaL0EAN9eBoB5LwfUAlTowXwf2f4YcElwgNkDjB1gtg9ZHy59BIz7YByi4CEKHmJsgKgTrGaA0gPUGsDoCIEejqD8gEAyhMUQ6xjWrxcA1BzBdgSjEVQj7MMIbiPsl4OA1EHPDrgOKjtwcrA3DrjOkuAYAaNj9OFC4CIgd6F0QXVR3sVCXZRy0YMHigeBB3MPK_Lg5KGCh7488HwEaD5682Hig-ZD5aMlH1wfJQJ4BiAHIAegBLAL0F2ATQ6gCODymeIjxSeKL2B-RUB8AsMTMqQTNMxJxRqLuwcijGrsAfdq_AF4X8OcRNeWqqahyDQdZ1BkJYuLgg7kuqUqdye1orc0XCzySNvSaRSfAHjCXreY6GQWM02hk1h5fLJJ9v-QizNSKrIsouUl3R3_ZmCo0G1SP0XCtLU1DZ-hztZspgnWYbFed6Yoy1UptUc6xTSpWWTXKv7LgvpKtAYN0nWzy15MvtHmYEFEv1bvPtGHW-wv)
[Answer]
## Pascal, 352 bytes
This `function` requires a processor supporting features of ISO standard 10206 ‚ÄúExtended Pascal‚Äù, in particular the `string` schema data type and `index` string search function.
```
type t=string(3);function f(s:t):Boolean;begin case length(s)of 1:f:=index('BCFHIKNOPSUVWY',s)>0;2:f:=odd(index('AcAgAlAmArAsAtAuBaBeBhBiBkBrCaCdCeCfClCmCnCoCrCsCuDbDsDyErEsEuFeFlFmFrGaGdGeHeHfHgHoHsInIrKrLaLiLrLuLvMcMdMgMnMoMtNaNbNdNeNhNiNoNpOgOsPaPbPdPmPoPrPtPuRaRbReRfRgRhRnRuSbScSeSgSiSmSnSrTaTbTcTeThTiTlTmTsXeYbZnZr',s));otherwise f:=6=9 end end;
```
Ungolfed:
```
type
    { A schema data type `string` is an Extended Pascal extension.
      Here we discriminate `string` to have (at least) a capacity
      exceeding one character than the longest abbreviation. }
    tripleCharacter = string(3);
{ NB: When calling with a string literal longer than three characters,
      the extra character are silently clipped. }
function isElementAbbreviation(protected sample: tripleCharacter): Boolean;
    const
        single = 'BCFHIKNOPSUVWY';
        double = 'AcAgAlAmArAsAtAuBaBeBhBiBkBrCaCdCeCfClCmCnCoCrCsCu' +
                 'DbDsDyErEsEuFeFlFmFrGaGdGeHeHfHgHoHsInIrKrLaLi' +
                 'LrLuLvMcMdMgMnMoMtNaNbNdNeNhNiNoNpOgOs' +
                 'PaPbPdPmPoPrPtPuRaRbReRfRgRhRnRuSbScSeSgSiSmSnSr' +
                 'TaTbTcTeThTiTlTmTsXeYbZnZr';
    begin
        case length(sample) of
            1:
            begin
                { In Pascal `string`s indices are 1-based.
                  `index` returns `0` if nothing was found. }
                isElementAbbreviation := index(single, sample) > 0;
            end;
            2:
            begin
                { Do not match, for example, `'cA'`. }
                isElementAbbreviation := odd(index(double, sample));
            end;
            otherwise
            begin
                isElementAbbreviation := false;
            end;
        end;
    end
```
[Answer]
# Python, 229 bytes
Thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil) for the regex - :)
```
import re;bool(re.match("([HNOUVWY]|[CGLP]a|[DNPRSTY]b|[AMST]c|[CMNP][do]|Gd|[BCFGHNRSTX]e|[CHR]f|[AHMORS]g|[BNRT][ah]|[BLNST]i|Bk|[ACFT][lm]|Pm|Sm|[CIMRSZ]n|Ho|Np|[AELZ]r|[BCFIKPS]r?|[ACDEHOT]s|[AMP]t|[ACELPR]u|Lv|Dy)",input()))
```
...go brr
]