Convert superscript numbers to normal numbers

Question

Introduction

My gnome friends are writing a programming language and have asked for my help. Due to their size, the gnomes can only handle small superscript numbers instead of big numbers. However, the language they're writing the interpreter in only accepts big numbers!

Your Challenge

Given an input of a superscript number (a series of characters that can be any of ⁰¹²³⁴⁵⁶⁷⁸⁹), convert it to normal ASCII numbers and print the result. This is code golf, so shortest answer wins!

Test Cases

¹ -> 1
⁵ -> 5
¹²³ -> 123
⁶⁵⁵³⁵ -> 65535
⁰¹²³ -> 123

Answer 1

JavaScript, 20 bytes

s=>s.normalize`NFKD`

Try it online!

Answer 2

JavaScript (ES6), 43 bytes

Edit: +1 to support 0123 -> 123 ...

s=>+s.replace(/./g,c=>c.charCodeAt()%92%12)

Try it online!

Conversion table

 char. | code | mod 92 | mod 12
-------+------+--------+--------
  '⁰'  | 8304 |   24   |   0
  '¹'  |  185 |    1   |   1
  '²'  |  178 |   86   |   2
  '³'  |  179 |   87   |   3
  '⁴'  | 8308 |   28   |   4
  '⁵'  | 8309 |   29   |   5
  '⁶'  | 8310 |   30   |   6
  '⁷'  | 8311 |   31   |   7
  '⁸'  | 8312 |   32   |   8
  '⁹'  | 8313 |   33   |   9

Answer 3

Hexagony, side length 4, 37 bytes

92},/%=\_@=..}{<.{\<.>".2//{%.1!}>'/_

Unwrapped code:

    9 2 } ,
   / % = \ _
  @ = . . } {
 < . { \ < . >
  " . 2 / / {
   % . 1 ! }
    > ' / _

Try it on hexagony.net

This is my first post on Code Golf, and first time using Hexagony. It's as painful as the name implies, but so satisfying to get a result! I ended up with more mirrors than I expected, but I'm pretty proud of what I achieved.

Credit to the previous users who worked out the modulo trick. My hexagon would have been a lot bigger without %92%12!

Answer 4

Jelly, 7 bytes

O%12&ƊḌ

Try it online!

O         Get ordinal values
 %12&Ɗ    Apply x ↦ x%12&x
      Ḍ   Digits to number

I found the x%12&x formula by computer search. If I/O were super duper lenient, I guess %12& would be a valid 4-byte answer.

Answer 5

R, 45 53 51 bytes

Edit +8 bytes to comply with the updated rules (0123 -> 123), but then -2 bytes thanks to pajonk

function(s)el(chartr("⁰¹²³⁴-⁹","0-9",s):1)

Try it online!

---

R, 53 51 57 bytes / 25 bytes with IO as character codes

Edit: -4 bytes thanks to pajonk, but then +6 bytes (again thanks to pajonk) to comply with the updated rules

function(s,x=utf8ToInt(s))el(intToUtf8(x%%64-8*!x-185):1)

Try it online!

Function without multi-byte character codes, but sadly the verbose utf8ToInt and intToUtf8 function names make it quite long if we want to accept input directly as a string...

The new rule that ⁰¹²³ should output 123 invalidates the second version with IO as character codes. It could be fixed for +17 bytes, but it's shorter to completely change approach (below), porting Arnauld's charcode-to-digit method.

---

R, 40 bytes with IO as character codes

function(c)c%%92%%12%*%10^rev(seq(!c)-1)

Try it online!

Answer 6

Charcoal, 2 bytes

ＩＶ

Try it online! Explanation:

 Ｖ  Eval as a Charcoal integer literal
Ｉ   Cast to string
    Implicitly print

Answer 7

Python 3.8 (pre-release), 46 50 bytes

-1 thanks to ovs!

lambda x:int(x.translate('%7d   45678923'%10*999))

Try it online!

Helper program to generate this: helper

Answer 8

C (gcc), ^{83 \$\cdots\$ 60} 46 bytes

n;f(int*s){for(n=0;*s;)n+=9*n+*s++%92%12;n=n;}

Try it online!

Inputs a pointer to a wchar_t string of superscript numbers.
Returns the normal number.

Discovered the n % 92 % 12 formula independently.

Answer 9

Raku, ^{14 10 11} 8 bytes

+1 and +4 to remove leading 0's.

-3 bytes thanks to Moonchild!

+~*.NFKD

Try it online!

---

Raku -p, 15 19 bytes

-1 byte and -1 flag thanks to Jo King!

$_=+S:g{.}=$/.EVAL

Try it online!

Raku uses superscript digits as exponents, but single digits on their own evaluate to their numeric value.

Answer 10

Vyxal, 7 bytes

C:12%⋏ṅ

Try it Online!

Port of Lynn's answer thanks to steffan.

Answer 11

Python 3, 53 bytes

from unicodedata import*
lambda s:normalize("NFKC",s)

Try it online!

Answer 12

Pip, 9 12 bytes

+3 bytes to handle more stringent rules

+:A_%E#A_MJa

Replit! (Note: the Unicode input seems not to play well with Pip's interactive mode, or maybe it's a Replit issue. For best results, Ctrl-C out of the default interactive mode and enter ./pip.py -e A_%E#A_Ma ⁶⁵⁵³⁵ at the command prompt.)

Or, here's a 14-byte equivalent in Pip Classic: Try it online!

Explanation

After some trial and error, I found a really nice property of these numbers' codepoints:

• ¹, ², and ³ have codepoints 185, 178, and 179. Mod 8 (or 4), these become 1, 2, and 3.
• The other superscript numbers have codepoints equal to the corresponding digit plus 8304. Mod 16 (or 12, or many other options), these become their respective digits.

So all we need to do is take the codepoint of each digit mod 8 if it's 3 digits and mod 16 if it's 4 digits...

          a  First command-line argument
        MJ   Map this function to each character, joining the results together:
  A_          Codepoint of the character
    %         Mod
     E        2 to the power of
      #       Length of
       A_     Codepoint of the character
+:           Treat the resulting string as a number (removing leading 0s)

Answer 13

05AB1E, 11 8 bytes

Ç92%12%J

-3 bytes porting @Arnauld's JavaScript method (thanks @Neil for the heads up).

Add a trailing ï (+1 byte) if you want to remove leading 0s..

Try it online or verify all test cases.

Explanation:

Ç         # Convert the (implicit) input to a list of its codepoint-integers
          #  e.g. "⁰¹²³⁴⁵⁶⁷⁸⁹" → [8304,185,178,179,8308,8309,8310,8311,8312,8313]
 92%      # Modulo-92
          #  → [24,1,86,87,28,29,30,31,32,33]
    12%   # Modulo-12
          #  → [0,1,2,3,4,5,6,7,8,9]
       J  # Join the list together
          #  → 0123456789
        ï # (Optionally) Remove leading 0s by casting to an integer
          #  → 123456789
          # (after which the result is output implicitly)

Answer 14

JavaScript, 65 62 61 60 bytes

s=>s.replace(/./g,x=>-~'¹²³⁴⁵⁶⁷⁸⁹'.search(x))

Saved 3 bytes thanks to Neil.

Saved 1 byte thanks to Shaggy.

Saved 1 byte thanks to Arnauld.

Try it online!

Answer 15

Retina 0.8.2, 19 bytes

T`⁰-⁹_¹²³`dd

Try it online! Link includes test cases. Explanation: d is a shorthand for 0123456789. As ⁰-⁹ expands to ⁰ⁱ⁲⁳⁴⁵⁶⁷⁸⁹, and assuming none of ⁱ⁲⁳ will appear in the input, those supserscript digits will get mapped to ASCII digits, while the _¹²³ gets mapped to 0123 (the remaining digits in d get ignored). _ is actually a placeholder on the LHS and does nothing except to skip 0 on the RHS (on the RHS it causes the character on the LHS to be deleted).

Answer 16

Japt -m, 7 bytes

Use Arnauld's formula so be sure to upvote him.

c %#\%C

Try it

Answer 17

C (gcc) with -funsigned-char, 63 bytes

This version takes a string of UTF-8 characters. If the leading byte is E2 then I mask the third byte with 15; otherwise I mask the second byte with 3. It's useful that B9 (the trailing byte of ¹) is odd!

i;f(char*s){for(i=0;*s;s++)i=(*s++-226?*s&3:*++s&15)+i*10;i=i;}

Try it online!

Answer 18

APL (dzaima/APL), 16 15 bytes

−1 byte thanks to rak1509

Anonymous tacit prefix function. Requires 0-based indexing.

10⊥'⁰¹²³⁴⁵⁶⁷⁸'⍳

Try it online!

10⊥ evaluate in base 10

'⁰¹²³⁴⁵⁶⁷⁸'⍳ the respective indices of the argument characters in this string (any character not in the string gets the first index beyond the end, i.e. 9)

Answer 19

APOL, 46 27 bytes

I(j(ƒ(i %(%(↶(∋) 92) 12))))

Uses Arnauld's 92/12 solution.

Note: 3 bytes can be saved by removing the I instruction, however this version is not case 5-compliant.

Explanation

I(               Cast to integer
  j(             Join string (default is no seperator)
    ƒ(           List-builder for loop (returns a list of every returned value of the passed instruction)
      i          Get input
      %(         Modulo 2 (12)
        %(       Modulo 1 (92)
          ↶(     Get codepoint
            ∋    The current item in the for loop
          )
        92
        )
      12
      )
    )
  )
)
Implicit print

Old code (uses lookup table instead):

v(0 []);f(i a(0 t(⌕("⁰¹²³⁴⁵⁶⁷⁸⁹" ∋))));I(j(⁰))

Answer 20

Nibbles, 6.5 6 bytes (12 nibbles)

`@~.$`&%$12

A port of Lynn's Jelly answer comes out half-a-byte a byte shorter in Nibbles.

   .            # Map over 
    $           # the input string:
     `&         #  bitwise-and of
        $       #  each element
       %        #  modulo
         12     #  twelve
                #  and itself
`@~             # Finally, convert from base-10 digits

Answer 21

Python 3, 63 62 bytes

lambda n: int("".join([str("⁰¹²³⁴⁵⁶⁷⁸⁹".index(c))for c in n]))

Thanks @Fmbalbuena!

Answer 22

Husk, 10 9 bytes

dm(Sn%12c

Try it online!

Port of Arnauld's Javascript answer Lynn's Jelly answer.

The 'charcode-to-charcode' modulo-except-when-it's-185 approach is discouragingly long in Husk, but Lynn's 'charcode-to-digit' modulo-AND approach is very well-suited to Husk's d (digits to decimal number) function.

Answer 23

PHP, 35 bytes

<?=+iconv('','US//TRANSLIT',$argn);

Try it online!

Some nice PHP builtin

Answer 24

Nim, 63 bytes

import strutils,unidecode
stdin.readAll.unidecode.parseInt.echo

Try it online!

If removing leading zeros is not required:

Nim, 45 bytes

import unidecode
stdin.readAll.unidecode.echo

Try it online!

Answer 25

Turing Machine Code, 99 bytes

* ⁰ 0 r *
* ¹ 1 r *
* ² 2 r *
* ³ 3 r *
* ⁴ 4 r *
* ⁵ 5 r *
* ⁶ 6 r *
* ⁷ 7 r *
* ⁸ 8 r *
* ⁹ 9 r *

Try it online!

Answer 26

Ruby, 40 bytes

->s{s.tr("⁰-⁹¹²³","0-9123").to_i}

Try it online!

Answer 27

Factor, 13 bytes

[ nfkd dec> ]

nfkd postdates the build TIO uses, so have a screenshot:

Answer 28

Lua, 94 bytes

r=0 t={[185]=1,[178]=2,[179]=3}for _,c in utf8.codes(...)do r=r*10+(t[c]or c-8304)end print(r)

Try it online!

Answer 29

Excel, 72 63 bytes

^{Saved 9 bytes thanks to JvdV}

=--CONCAT(MOD(MOD(UNICODE(MID(A1,SEQUENCE(LEN(A1)),1)),92),12))

Not very exciting, really. It's the Excel version of Arnauld's answer.

• MID(A1,SEQUENCE(LEN(A1)),1) pulls each character from the input one at a time.
• MOD(MOD(UNICODE(MID(~)),92),12)) converts that character to unicode and then takes the mod 92 and mod 12.
• --CONCAT(MOD(~)) combines all those code values into a string and then coerces that string into a number by making it negative twice (so back to positive again) which also will drop any leading zeros.

Answer 30

Prolog (SWI), 40 bytes

A+O:-unicode_nfkd(A,C),atom_number(C,O).

Try it online!

Builtins