[Question]
  [
### Background
The [systematic chemical symbol](https://en.wikipedia.org/wiki/Systematic_element_name) is defined as such for \$ 118 < n < 1000 \$:
* The first letter corresponds to the first digit, capitalized.
* The second letter corresponds to the second digit.
* The third letter corresponds to the third digit.
This can be generalized for all \$ n > 0\$:
* For each digit, get the corresponding letter.
* Capitalize the first character.
### Task
Write a function or full program that takes an integer or a list of digits \$n > 0\$ and returns or prints the corresponding systematic chemical symbol.
```
Digit | Letter
--------------
0     | n
1     | u
2     | b
3     | t
4     | q
5     | p
6     | h
7     | s
8     | o
9     | e
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so ***shortest code wins.***
### Test Cases
```
In - Out
----------
119 - Uue
120 - Ubn
123 - Ubt
999 - Eee
6859 - Hope
1 - U
92 - Eb
987654321 - Eoshpqtbu
1010101 - Unununu
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
Input is a list of digits.
```
.•*Š"—Êo•sèJ™
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f71HDIq2jC5QeNUw53JUP5BQfXuH1qGXR///RhjoKQGQZCwA) or [Try all cases!](https://tio.run/##yy9OTMpM/V9Waa@koGunoGRf@V/vUcMiraMLlB41TDnclQ/kFB9e4fWoZdF/nf/R0YY6hjqWsTpA2kjHAEobA2lLHUuwuJmOhY4pRAVY1AhMWuiY65gBxU10jIHqDcH6DHTgODYWAA "05AB1E – Try It Online")
**Commented:**
```
.•*Š"—Êo•      # compressed alphabet string "nubtqphsoe"
         s     # swap to implicit input
          è    # index each digit into the string
           J   # join into a single string
            ™  # apply title case
```
See the step-by-step output [here](https://tio.run/##Zcw9CsJAEAXg3lMMKSXY@IMKYu8VxGKyWZIJ6@6SWVG7FFbWHkBSeY/gRXKRdVFiQF/34HvPMCYkvR@1VT183qO2ujVXEwpEwuxtKZllCqhsjol0wK4knS0hGk@K9WrA0CXiI1pwBmhvFQlyQNoe3Fc2j56STuUJJIocUsreNAxdLn/vN/2mMKQ/DoGDUX@4vdQ9R2vVGRy54ASy7JT321kM8ximMSx2Lw).
---
[Lyxal](https://codegolf.stackexchange.com/users/78850/lyxal) has suggested another 13-byter with a nicer input format:
```
.•*Š"—Êo•ÅвJ™
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f71HDIq2jC5QeNUw53JUP5BxuvbDJ61HLov//zSxMLQE "05AB1E – Try It Online")
This uses `Åв`, which converts the input integer into the custom base defined by the string.
[Answer]
# [Haskell](https://www.haskell.org/), 43 bytes
```
f(h:t)="NUBTQPHSOE"!!h:map("nubtqphsoe"!!)t
```
[Try it online!](https://tio.run/##TU7LasMwELzrKxTTQwIbkOzYsQK5FAw59EmaUzDFNnJV6shKJf1@1ZVaSllWMzszi1Z19kNOUwjjUu3cap89nG5fnp8Ox8cmWyzU7tKZZaZ9765G2VmitnLBSeteh85KS/f0fObAQbSAmAP7xQKRAUtzBTWUPwlsAXl6a9hChfoGCszztMfgr9uWXLp3jR/gCffUeHd0n3ea3sSZjoj/rgicC7qmJy8Jz1lkvUZWJOaIENFtpCRVXUZ6mA0mo0tEHq2eiHpblZsij2ozW2WurveEs1QxqX0s8jWMU/dmw3ow5hs "Haskell – Try It Online")
Input is a list of digits. Yes, the code really just writes out the string once in uppercase and a second time in lowercase. This kludge seems shorter than other things I tried. Haskell without imports doesn't have built-ins to capitalize and is really clumsy in working with characters.
**43 bytes**
```
zipWith(!!)$"NUBTQPHSOE":repeat"nubtqphsoe"
```
[Try it online!](https://tio.run/##TU5Na8MwDL37V7ihhw1UsJ0mjQe9DAI97JO27NCG4gRnCUsdt7Yv@/Hz7GyMIaT3pPeE1AnzIYfBt@uj/@z1W2@7m9nsdp487e93ry@b7XOZ3F2llsImytX2ojszysRbaeypEUYavMaHAwUKvIKADMgvpgEJkKnPoYDsxxGSA5tqASvIw3wJafDTaY/AX1YVOotehQNnoR@xdnZrrw8Kz2OP24D/vvCUcrzAeycRZSSyWgWWTswizqNaSonyIot0M@rgjCriLEo14sUqz5Ypi9NyNJ2@2NohSqaITuVioK@mHcS78YtG628 "Haskell – Try It Online")
Taking [Lynn's solution](https://codegolf.stackexchange.com/a/214057/20260) and making it more boring. We can also write:
**43 bytes**
```
zipWith(!!)$"NUBTQPHSOE":l
l="nubtqphsoe":l
```
[Try it online!](https://tio.run/##TU7LasMwELzrKxSTQwMbkOTYsQq@FAw59BXS0ENqim3k2lSRlUq@9OOrSmopZdmd2ZkR2qEx70JK15cv7nPUz6MdrhaL1TK5P9487R93h4cquZZIlomaW3vRg5mEF5wVxr52jREGl/h0okCB1@CRAfnF1CMBEvccCsh@Er45sDgL2ELu9Q2kPk/jOwJ/Xdfo3IzKf3Bu9B3Wsz3Yj1uFl2HHvcd/VzhKOV7j4ywQZSSwVnmWRmYR58GthEB5kQW6m7RPBhdxFqwW8WKbZ5uUBbWazKAvtp0RJbFCUs2h0FfXy@bNuHWn9Tc "Haskell – Try It Online")
**47 bytes**
```
(%0)
(h:t)%i=["NUBTQPHSOE"!!h..]!!i:t%32
_%_=""
```
[Try it online!](https://tio.run/##TU7baoNAEH3fr1ilQgKTsJdo3IAvBSEPvZLmyYqorFVqzLa7/n7t7raUMsycM3POMNPX@l2O49Jlr8sqImu06g9mHQ1ZET6cb1@en46nxzwMgn67LYNgOJiIM1RFVRaGi5HaVG2tpcYZLgoKFEQJFhmQX@QWCRDfJ5BC/OOwKYD5msIeEjvfAbd@6vcI/GVZoks9TPbApVb3WM3mZD7vJnzjetxZ/PfFQqnAG3yeJaKMONZMlnHPDBLCqbmUKEljR49XZZ1ORYI5qUEi3SfxjjM3za@6Vx@mmRElPpxzml2gr7Yb6ze9bFqlvgE "Haskell – Try It Online")
Based off [Lynn's solution](https://codegolf.stackexchange.com/a/214057/20260). Handles the capitalization by passing in an offset `i` of 0 initially, then updating it to 32 in each recursive function call.
It doesn't seem like Haskell has a nice function to title-case a string even with imports, which are probably too lengthy anyway to be competitive. The below with `Data.Text` doesn't work because it operates on `Text` not `[Char]`. `Data.Char` only has `toUpper` to capitalize a single character.
*44 bytes (non-working)*
```
import Data.Text
toTitle.map("NUBTQPHSOE"!!)
```
[Try it online!](https://tio.run/##TU5Na8MwDL37V7hlhw3UYjtNGh96KQv0sE@ankoYTnDXsHx4tQL79fNsr4whpPek94R0VvZDd51zbW/GC9J7hWpZ6i8kOJYtdnrZK3M7fzpsy9eX3f65mM9mdw61xbdGWW3phh6PHDjICjwKYFdMPDJgsc8gh/TX4VOCiDWHNWR@voLE@3ncY/CXVUV61Q7@gP/gkZoJ93h5GOhN6OnJ478vHOeSLuhh0oQLFlg9eJZEhkTKoBZakyxPA92NxjuDSqQIUk1kvs7SVSLCtBjt2XxiPRHOYgTnMIUg382pU@/WLRpjfgA "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
ị“ubtqphsoen”Œt
```
[Try it online!](https://tio.run/##y0rNyan8///h7u5HDXNKk0oKCzKK81PzHjXMPTqp5L/L4fZHTWsi//@3tDA3MzUxNjLUUTA0tAQSRgYgwhgA "Jelly – Try It Online")
Inputs as a list of digits, which the Footer does for you.
As it appears the string can't be compressed, this is likely to be the shortest approach in Jelly
## How it works
```
ị“ubtqphsoen”Œt - Main link. Takes a list l on the left
 “ubtqphsoen”   - Yield the string “ubtqphsoen”
ị               - For each digit in l, index into the string (1-indexing)
             Œt - Title case (capitalise the first character)
```
[Answer]
# [R](https://www.r-project.org/), ~~80~~ ~~72~~ 56 bytes
-8 bytes thanks to Kirill L.
-16 bytes thanks to Giuseppe.
```
sub("(.)","\\U\\1",chartr("0-9","nubtqphsoe",scan()),,T)
```
[Try it online!](https://tio.run/##K/r/v7g0SUNJQ09TSUcpJiY0JsZQSSc5I7GopEhDyUDXEiiaV5pUUliQUZyfqqRTnJyYp6GpqaMTovnf0sLczNTE2MjwPwA "R – Try It Online")
First we translate the digits to the relevant letters thanks to `chartr`, then `sub` switches the first letter to upper case. This last part is possible thanks to the option `perl = T`, a nice trick found by Giuseppe.
Also, note that all the functions are vectorized the way we need them to be, so we can handle several inputs at a time, which is rather unusual in R golf with `scan()`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~17~~ 16 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Input as a digit array, output as a character array.
```
mg`eo¢pqt¿n`w)vu
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=bWdgZW%2bicHF0v25gdyl2dQ&input=WzEsMSw5XQ)
```
mg`...`w)vu     :Implicit input of digit array
m               :Map
 g              :  Index (0-based) into
  `...`         :    Compressed string "eoshpqtbun"
       w        :    Reversed
        )       :End map
         v      :Modify first element
          u     :  Uppercase
```
[Answer]
# [Haskell](https://www.haskell.org/), 48 bytes
```
zipWith(\i d->["NUBTQPHSOE"!!d..]!!i)$0:k
k=32:k
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzvyqzIDyzJEMjJlMhRdcuWskv1CkkMMAj2N9VSVExRU8vVlExU1PFwCqbK9vW2Mgq@39uYmaebUFRZl6JRppCtKGOkY6xjomOaazm/3/JaTmJ6cX/dZMLCgA "Haskell – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~20~~ 17 bytes
```
§:oa←tm!¨Ḃ+q²"ṗen
```
[Try it online!](https://tio.run/##ASoA1f9odXNr///CpzpvYeKGkHRtIcKo4biCK3HCsiLhuZdlbv///1sxLDEsOV0 "Husk – Try It Online")
input as a list of digits.
There's probably a better way to do the titlecasing part.
-3 bytes from Dominic van Essen.
## Explanation (old)
```
§:oa←tmo!¨nḂ+q²"ṗe¨→
                   → increment input to accomodate 0-indexing
      mo             map each digit to
        !¨nḂ+q²"ṗe¨  it's index value in the compressed string
§:                   join the
  oa←                first letter uppercased
     t               with it's tail
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~20~~ 18 bytes
```
⭆⍘Ｎnubtqphsoe⎇κι↥ι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaDglFqdCeBqeeQWlJX6luUmpRRqaOgpKeaVJJYUFGcX5qUpAbkhqUV5iUaVGto5Cpo5CaEFBalEyUK9GpiYQWP//b2ZhavlftywHAA "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 2 bytes thanks to @Lyxal's comment on @ovs's answer. Explanation:
```
  Ｎ                 Input number
 ⍘                  Custom base conversion using
   nubtqphsoe       Literal string
⭆                   Map over characters
              κ     Current index
             ⎇      If not first character then
               ι    Current character
                ↥ι  Else uppercased character
                    Implicitly print
```
[Answer]
# [Python 3](https://docs.python.org/3/), 51 bytes
```
lambda a:"".join("nubtqphsoe"[x]for x in a).title()
```
[Try it online!](https://tio.run/##BcFbCoAgEADAq4hfCktQ9oZOUn0oJRm1mm1Qp7eZ8NHmUSU7TOnQp1k00z3n2e4dCo6PoStst1/5@M7WR/Yyh0zLjBwdq5ApRIckrBg7aKGBGiooQUEB@Sxl@gE "Python 3 – Try It Online")
---
# [Proton](https://github.com/alexander-liao/proton), 42 bytes
```
a=>"".join("nubtqphsoe"[x]for x:a).title()
```
[Try it online!](https://tio.run/##BcFbCoAgEADAq4RfCovQ@wF2EfHDQMkI12wDb28zKSNhrF5Vq3bG5IUhcha/g550vuiYLsZjbspmhaRAt@Oiphwicc/1CgvMMMEIA/TQQWuEqD8 "Proton – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~51~~ 49 bytes
Apparently I can get rid of the customary "assign to first parameter" because I only care about a false/non-false answer from this function. Interesting to know!
```
f(n){n&&putchar("nubtqphsoe"[n%10]^32*!f(n/10));}
```
[Try it online!](https://tio.run/##HY7bCoJAEIbvfYpJKHY90O6apiw@iRhsWx6gVvNQF@Krt40xzMD3Mfz8Oqy1trYihi7mcOjnSTdqIK6Zr9Orb8bu7hZmz1l5iYS3w7cjZ5TK1bZmgqdqDXl37Y3C4gBsSg1DUeYL51kAXLDtRAFkGWKSxptEErjpOYlPkUDk7D8BsDUAT@UYIR2Mq7qBSBQSsNVIXJdSqIinfJ9KZ7VfXT1UPdrw8wM "C (gcc) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-nl`, 37 bytes
```
p$_.tr("0-9","nubtqphsoe").capitalize
```
[Try it online!](https://tio.run/##HchNCoAgEEDh/RxDWhSUOPY7pwmLICHU0hZ1@KaIx7d5xzldzCEbZTpyoSoSpXDnlPawRr@IQs4m2GQ2ey/MiASo1acGIoJuaL8BpIGGvmubWiOg@nt8SNa7yJXbXg "Ruby – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 27 bytes
```
y/0-9/nubtqphsoe/;$_="\u$_"
```
[Try it online!](https://tio.run/##K0gtyjH9/79S30DXUj@vNKmksCCjOD9V31ol3lYpplQlXun/f0NDSy5DIwMgNuaytLTkMrMwBQpwWRpxWVqYm5maGBsZchkagOG//IKSzPy84v@6BQA "Perl 5 – Try It Online")
[Answer]
# JavaScript (ES6), 54 bytes
Expects an array of digits.
```
a=>a.map((c,i)=>"nNuUbBtTqQpPhHsSoOeE"[c*2+!i]).join``
```
[Try it online!](https://tio.run/##bdBND4IgGMDxe5@iOmk9mdmrBz20tXXqZeWptQVEZTOgkL4@YZutiTBuv/H84Y7eSJJXKvIe42eqL5FGUYy8BxKOQyB1o7jNVirB83z/3IrNbSl3fE0X7QPpBN1WenS9O0/Z6aQJZ5Jn1Mv41bk4hwEMIDy6bvN/9fvNRNGGRQPw6yhmdXRYS/MqDSGsDVhQK2ACMxhXsaFLLuzY6pVlgT0/sKmBK2zLGUxhYhJGMDQP/I4oSrm8iWeOlf0LPvxOOaRoYKrY@gM "JavaScript (Node.js) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~11~~ 10 bytes
```
«/
∨+Ċ≤«βǐ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%AB%2F%0A%E2%88%A8%2B%C4%8A%E2%89%A4%C2%AB%CE%B2%C7%90&inputs=999&header=&footer=)
I finally turned my suggested 13 byte 05AB1E answer into a Vyxal answer.
## Explained
```
«...«βǐ
«...«    # the string "nubtqphsoe"
     β   # convert the input to bijective-base 10 using the above string as the alphabet
      ǐ  # titlecase that result
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 26 bytes
```
T`d`nubtq\p\hs\oe
T`l`L`^.
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPyQhJSGvNKmkMKYgJqM4Jj@VKyQhJ8EnIU7v/39DQ0suQyMDIDbmsrS05DKzMAUKcFkacVlamJuZmhgbGXIZGoAhAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
T`d`nubtq\p\hs\oe
```
Translate each digit to the appropriate letter. The letters `h`, `o` and `p` have special meaning, so they need to be quoted.
```
T`l`L`^.
```
Translate the first letter to upper case.
[Answer]
# APL+WIN, 39 bytes
Prompts for a character vector of digits with index origin = 0
```
⎕av[(↑n),32+1↓n←⎕av⍳'NUBTQPHSOE'[⍎¨⍕⎕]]
```
Explanation:
```
[⍎¨⍕⎕]] Convert input to individual digits
⎕av⍳'NUBTQPHSOE' Find index positions of all upper case characters in atomic vector
and use result above to select those according to input
(↑n),32+1↓n Concatenate first index to remaining indices + 32 to apply appropriate case
⎕av[...] Use the above indices to select required characters from atomic vector
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), ~~31~~ ~~29~~ 28 bytes
```
~{"nubtqphsoe"1/=}%()[32-]|\
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v65aKa80qaSwIKM4P1XJUN@2VlVDM9rYSDe2Jub//2gzBQsFUwXLWAA "GolfScript – Try It Online")
Input as a digit array.
```
~                             # Parse the input to an array         [6 8 5 9]
 {               }%           # For each digit
  "nubtqphsoe"1/              # Split each letter of this string    6 ["n" "u" ... "e"]
                =             # Get the corresponding letter        "h"
                   (          # Get the first letter                ["o" "p" "e"] "h"
                    )         # Get the ascii value                 ["o" "p" "e"] "" 104
                      32-     # Subtract 32                         ["o" "p" "e"] "" 72
                     [   ]    # Put it in an array                  ["o" "p" "e"] "" [72]
                          |   # Convert to ascii                    ["o" "p" "e"] "H"
                           \  # Swap the two elements in the stack  "H" ["o" "p" "e"]
                              # Only the strings are outputted      "Hope"
```
[Answer]
# [Scala](http://www.scala-lang.org/), ~~47~~ 40 bytes
```
_+""map(d=>"nubtqphsoe"(d-48))capitalize
```
[Try it online!](https://tio.run/##Vc1NC4JAEIDhu79i8KSE@G1aKHgQ6tCxc@zqioaNa67RB/12ow7bytzmZZ4ZS9KRuadnVgo4kBaB3QXDaoSc85d2Ix3UG9ijgDSDHB@QzqeVrl8IN6o003GiYuDN2DPdqKwgNs2S8FaQrn2yeavxa4uiQ6M2XDcxTbBtsOA4MTV4jgwUF8H/B6GEJJFUwVQqikNZdj1ffJGUCnnSoeo6Xkdh4HvypujHhg@CTiro/EayOH1He88f "Scala – Try It Online")
* -7 Thanks to [user](https://codegolf.stackexchange.com/users/95792/user)!
[Answer]
# x86 machine code (MS-DOS .COM format), ~~35~~ 33 bytes
The program will terminate at the end of input from the command line.
For fun, I decided to use `XLAT` to index each digit's representation as the translation array easily fits into an 8-bit index and everything is 1:1.
Byte representation:
```
0000    B4 20 BB 19 01 BE 82 00 AC 2C 0D 74 09 D7 32 C4
0010    CD 29 32 E4 EB F0 C3 6E 75 62 74 71 70 68 73 6F
0020    65
```
Assembly code (TASM):
```
IDEAL
MODEL TINY
CODESEG
ORG 100H
SYMS_M EQU OFFSET SYMS-23H
MAIN:
    MOV AH,20H
    MOV BX,SYMS_M
    MOV SI,82H
VAL:
    LODSB
    SUB AL,0DH
    JZ  QUIT
    XLATB
    XOR AL,AH
    INT 29H
    XOR AH,AH
    JMP VAL
QUIT:
    RET
SYMS DB "nubtqphsoe"
END MAIN
ENDS
```
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), 105 bytes
Terrible implementation, it works at least, input is each digit of the number then any other character to terminate. Feel free to suggest any optimisations.
```
~::68*`vnubtqphsoe
 v+4*96_@
 `
@_68*8--0 v
   v        <
v:~<,-*84g<
>:68*` v
 v+4*96_@
 `
@_68*8--0 g,^
```
[Try it online!](https://tio.run/##S0pNK81LT/3/v87KysxCK6EsrzSppLAgozg/lUuhTNtEy9Is3oFLIYHLIR4obaGra6BQxqWgoFCmAAU2XGVWdTY6uloWJuk2XHZgQ0BKsOtN14n7/9/MwtQyBQA "Befunge-93 – Try It Online")
[Answer]
# [Zsh](https://www.zsh.org/), 29 bytes
```
<<<${(C)$(tr 0-9 nubtqphsoe)}
```
[Try it online!](https://tio.run/##qyrO@P/fxsZGpVrDWVNFo6RIwUDXUiGvNKmksCCjOD9Vs/b/fzMLU0sA "Zsh – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~63~~ 60 bytes
Saved 3 bytes thanks to [AZTECCO](https://codegolf.stackexchange.com/users/84844/aztecco)!!!
```
f(a,l)int*a;{l--&&f(a,l)+putchar("nubtqphsoe"[a[l]]-!l*32);}
```
[Try it online!](https://tio.run/##ZZPfboIwFIfveYquiYZiyRQUIWy7W7IX8MqRhT91kjBAgcTM8Oyu0FLgDKPAx3d6fi01Nr/j@PE46SHNSJrXRujfM9NcLgVZlU0dn8OrjvMmqi/luSoYPobHLAjMp8ywLeK3D16GfsI014l21xA/OlCzqv4KN8cAvaL7hm6o11IJrQFadK2gPUJbwa2AHvUm5TsBHerS3QQ7cgAF9kOxpZA7IJfuqcPLt9TmDccab0ixpurb@sOkDGkJSc5QzUrNRKVXiVVGlU0lUp3HNoJkokuV/rLipMtm5FneGwOgaGZY0LCgYUPDhsYWGlto7KCxg4YDDQcae2jsoeFCw4WGBw2PyGXsNq2B2K1kcc0SsZT40DBMET5EuTjV3emd9fCjKMXDnkX9b1Gdy0sdNT3Pm@6D5fin4qp3ryrNE3bjg699efkyTwgDEh@tVr1JkPizzPYWH0lusd4J/KmCMpYPQvZPUImSIU/SpeE1fctk1rA7yivXTzpeJFhswiOXAjKO2GpQReYbwhNDzJLyHhOoZH1Rkc9uqdVrEJml22rt4w8 "C (gcc) – Try It Online")
Inputs a pointer to an array of digits and its length (since there's no way to know how long an array passed into a function as a pointer is in C) and prints the corresponding systematic chemical symbol.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 41 bytes
```
V.T,.T]."buÞ“;UØ".T]."09I–Ò"=:zeNhN;rz3
```
[Try it online!](https://tio.run/##K6gsyfj/P0wvREcvJFZPKamU4/C8Q5OtQw/PUAILGFh6HprGdHiSkq1VVapfhp91UZXx//9mFqaWAA "Pyth – Try It Online")
## Explanation
The main part of the program is `.T,.T]."buÞ“;UØ".T]."09I–Ò"`, which returns the list `[['u', '1'], ['b', '2'], ['t', '3'], ..., ['n', '0']]`. `."buÞ“;UØ"` is the packed string `ubtqphsoen`, and `."09I–Ò"` is the packed string `1234567890`. `.T]` splits them into characters, and `.T,` zips them together.
# Pyth, 24 bytes
```
Vz=+k@."bu\nL‘"vN;rk3
```
[Try it online!](https://tio.run/##K6gsyfj/P6zKVjvbQU8pqZSNIybP59BEcaUyP@uibOP//80sTC0B "Pyth – Try It Online")
This one is a port of [HyperNeutrino's Python 3 answer](https://codegolf.stackexchange.com/a/214049/91569).
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 24 bytes
```
q~{"nubtqphsoe"1/=}%(eu\
```
[Try it online!](https://tio.run/##S85KzP3/v7CuWimvNKmksCCjOD9VyVDftlZVI7U05v//aAMFCwUzIDZVsFQwVzAGsiwUjIAsEM8cyDaIBQA "CJam – Try It Online")
Input in the form of a digit array string.
[Answer]
# [Raku](http://raku.org/), 29 bytes
```
*.trans(^10=>'nubtqphsoe').tc
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfS6@kKDGvWCPO0MDWTj2vNKmksCCjOD9VXVOvJPm/tUJxYqWCkkq8gq2dQnWagkp8rZJCWn6Rgo2hoaWCoZEBEBsrWFpa2v0HAA "Perl 6 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~142~~ ~~100~~ 94 bytes
```
$k=[string]$args;0..9|%{$k=$k.replace([string]$_,'nubtqphsoe'[$_])};get-culture|% t*o|% *se $k
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyXbNrq4pCgzLz1WJbEovdjaQE/Pska1Giiukq1XlFqQk5icqgFXEq@jnleaVFJYkFGcn6oerRIfq1lrnZ5aoptcmlNSWpRao6pQopUPJLWKUxVUsv///29oaAkA "PowerShell – Try It Online")
[Answer]
# JavaScript, ~~264~~ ~~157~~ ~~150~~ 100 bytes
-107 bytes by replacing `if` statements with a JavaScript object to match each number with a corresponding string.
-7 bytes by using ES6 `for` loop through a string, and shorter arrow functions.
-50 bytes by replacing JavaScript Object with ES6 string indexing.
```
a='';o='nubtqphsoe';x=c=>a+=o[c];for(let e of prompt())x(e);alert(a[0].toUpperCase()+a.substring(1))
```
[Answer]
# [Lexurgy](https://www.lexurgy.com/sc), 101 bytes
Map a digit to its respective letter.
```
Class D {\0,\1,\2,\3,\4,\5,\6,\7,\8,\9}
a:
@D=>{N,U,B,T,Q,P,H,S,O,E}/$ _
@D=>{n,u,b,t,q,p,h,s,o,e}
```
[Answer]
## bash + coreutils, ~~40~~ 37 bytes
```
c=`tr 0-9 nubtqphsoe<<<$1`
echo ${c^}
```
]