Get the Systematic Chemical Symbol

Question

Background

The systematic chemical symbol 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, 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 1

05AB1E, 13 bytes

Input is a list of digits.

.•*Š"—Êo•sèJ™

Try it online! or Try all cases!

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.

---

Lyxal has suggested another 13-byter with a nicer input format:

.•*Š"—Êo•ÅвJ™

Try it online!

This uses Åв, which converts the input integer into the custom base defined by the string.

Answer 2

Haskell, 43 bytes

f(h:t)="NUBTQPHSOE"!!h:map("nubtqphsoe"!!)t

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!

Taking Lynn's solution and making it more boring. We can also write:

43 bytes

zipWith(!!)$"NUBTQPHSOE":l
l="nubtqphsoe":l

Try it online!

47 bytes

(%0)
(h:t)%i=["NUBTQPHSOE"!!h..]!!i:t%32
_%_=""

Try it online!

Based off Lynn's solution. 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!

Answer 3

Jelly, 15 bytes

ị“ubtqphsoen”Œt

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 4

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

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 5

Japt, 17 16 bytes

Input as a digit array, output as a character array.

mg`eo¢pqt¿n`w)vu

Try it

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 6

Haskell, 48 bytes

zipWith(\i d->["NUBTQPHSOE"!!d..]!!i)$0:k
k=32:k

Try it online!

Answer 7

Husk, ²⁰ 17 bytes

§:oa←tm!¨Ḃ+q²"ṗen

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 8

Charcoal, 20 18 bytes

⭆⍘Ｎnubtqphsoe⎇κι↥ι

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 9

Python 3, 51 bytes

lambda a:"".join("nubtqphsoe"[x]for x in a).title()

Try it online!

---

Proton, 42 bytes

a=>"".join("nubtqphsoe"[x]for x:a).title()

Try it online!

Answer 10

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

Answer 11

Ruby -nl, 37 bytes

p$_.tr("0-9","nubtqphsoe").capitalize

Try it online!

Answer 12

JavaScript (ES6), 54 bytes

Expects an array of digits.

a=>a.map((c,i)=>"nNuUbBtTqQpPhHsSoOeE"[c*2+!i]).join``

Try it online!

Answer 13

Vyxal, 11 10 bytes

«/
∨+Ċ≤«βǐ

Try it Online!

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 14

Retina 0.8.2, 26 bytes

T`d`nubtq\p\hs\oe
T`l`L`^.

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 15

Perl 5, 27 bytes

y/0-9/nubtqphsoe/;$_="\u$_"

Try it online!

Answer 16

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 17

GolfScript, 31 29 28 bytes

~{"nubtqphsoe"1/=}%()[32-]|\

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 18

Scala, 47 40 bytes

_+""map(d=>"nubtqphsoe"(d-48))capitalize

Try it online!

• -7 Thanks to user!

Answer 19

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 20

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!

Answer 21

Zsh, 29 bytes

<<<${(C)$(tr 0-9 nubtqphsoe)}

Try it online!

Answer 22

C (gcc), 63 60 bytes

Saved 3 bytes thanks to AZTECCO!!!

f(a,l)int*a;{l--&&f(a,l)+putchar("nubtqphsoe"[a[l]]-!l*32);}

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 23

Pyth, 41 bytes

V.T,.T]."buÞ“;UØ".T]."09I–Ò"=:zeNhN;rz3

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!

This one is a port of HyperNeutrino's Python 3 answer.

Answer 24

CJam, 24 bytes

q~{"nubtqphsoe"1/=}%(eu\

Try it online!

Input in the form of a digit array string.

Answer 25

Raku, 29 bytes

*.trans(^10=>'nubtqphsoe').tc

Try it online!

Answer 26

PowerShell, 142 100 94 bytes

$k=[string]$args;0..9|%{$k=$k.replace([string]$_,'nubtqphsoe'[$_])};get-culture|% t*o|% *se $k

Try it online!

Answer 27

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 28

Lexurgy, 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 29

bash + coreutils, 40 37 bytes

c=`tr 0-9 nubtqphsoe<<<$1`
echo ${c^}