TI-BASIC (TI-84 Plus CE Python), 55 23 bytes

didn't put much thought into this lol

BLUEBLUEBLUE+BLACKBLUEBLUEBLUEBLUE+DARKGRAY+RED

this works because BLUE, BLACK, DARKGRAY, and RED are variables that equal to set numbers so its easier to use certain commands that use numbers to change pixels or text to different colors

Bash, 29 bytes

echo $[I=$[]xAF,I*I+$[]xCBCA]

82795

Try it online

Explanation:

$[…] is an alternative form of $((…)) — the arithmetic context that supports C-like expressions.
Empty $[] yields 0, and only the last one of the comma-delimited ops within the arithmetic context is treated as the result.

The expression itself is just 0xAF² + 0xCBCA = 82795, found using a brute-force search.

Setanta, 61 bytes

scriobh(nasc@(thar(fad,["a","aaaa","a","","aaaaaaaaa"]))(""))

try-setanta.ie link

Raku (Perl 6) (rakudo), 13 bytes

say ord '㜝'

Attempt This Online!

Wolfram Language (Mathematica), 86 66 bytes

Saved 20 bytes thanks to an idea of DLosc!

Last@First@EntityValue[Interpreter["City"]["Tyler MN"],"ZIPCodes"]

Not super short, but fun: look up a city's ZIP code 😄

Previous code:

Last@First@EntityValue[Entity["City",{"Tyler","Minnesota","UnitedStates"}],"ZIPCodes"]

Bespoke, 52 bytes

its Josiah R W:developer,and this languages creato-r

That's me!

Standard Pascal, 45 bytes

begin write(ord('ŝ')*ord('Ű')+ord('?'))end;

Where the question mark refers to invisible ASCII code 2 character.

Uiua, 12 bytes

♭≡°⋕-@ ",Fz"

Explanation:

♭≡°⋕-@ ",Fz"
    -@ ",Fz" => subtract codepoint 32, returns [12, 38, 90]
♭≡°⋕         => convert to str and then all combine -> "123890"

Try this online!

C (tcc), 27 bytes

f(){printf("%d",'br'+'q');}

Try it online!

Output: 25315

I decomposed the desired value 0x62e3 into the sum 0x6271 + 0x72, which can be represented by character constants using only ASCII.

This technique can generate any number, but the arithmetic is different. For example, to print the number 128398, which appears in the previous answer:

g(){printf("%d",'yxd'/'>');}

Brainfuck: 35

id: 128398

-[>+>+<<-----]>--.+.>+++++.<+.>+.-.

Nim, 44 bytes

import unicode
echo int "𝥒".runeat len []

Try it online!

Nim (without unicode), 68 63 bytes

import math
var a,b,c=on.ord
a+=a;b+=a;c=a^b+a
echo a*b^c+b*a^c

Try it online!

Explanation:

OEIS A094125

3*2^10 + 2*3^10 = 121170

brainfuck, 50 33 bytes

>-[++>+[+<]>]>.-------.+.--.++++.

Try it online!

Shortened code by using Brainfuck constant for the initial 8 (ASCII 56)

Zsh, 18 bytes

[
<<<$[$?$#?#ABII]

Attempt This Online!

[ fails with exit code 2, so $? = 2. The string 2 has length 1, so $#? = 1. Then $?$#?#ABII interpets ABII from base 21, which gives 97857.

A translation of GammaFunction's boring solution also works:

Zsh, 12 bytes

<<<$[##𗹁]

Attempt This Online!

MATLAB / Octave, 16 14 bytes

'Ｚ'*['⦺']'

Try it online!

I was inspired by another answer which used matlab's very weak typing to subtract space from a string to get each digit of their id. I figured I could do something even worse: linear algebra with unicode characters!

matlab thinks of strings as an array of utf-8 bytes, and lets you abuse this without any consequences. read literally, we're taking the matrix product of 'Ｚ' with the transpose of '⦺' (basically a fancy way of doing a dot product).

utf-8 needs to represent all of unicode while still being backwards compatible with ascii. if you look at the binary, all ascii looks like 0xxxxxxx, where xxxxxxx is the unicode index of that character in binary, so it keeps all of that the same.

to reach the rest of unicode, utf-8 uses a cute length-thing: 110xxxxx means 'this character uses 2 bytes', and 1110xxxx means 'this character uses 3 bytes' and so on. all the 'extention' bytes that come after the first byte are marked with 10xxxxxx to show that they are part of the previous character. (so unicode chars with an index under 11 bits look like 110xxxxx 10xxxxxx, unicode chars with an index under 16 bits look like 1110xxxx 10xxxxxx 10xxxxxx, and unicode
chars with an index under 21 bits look like 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)

first, some analysis: with 3 bytes, the ascii range only gets up to 47628, with 4 bytes reaching 63504. neither of these are close to my id (119818). we actually would need at least 8 bytes on both sides if we were limited to ascii chars

however, non-ascii utf-8 bytes must necessarily have the top bit set, meaning they are much bigger. instead of each number sitting between 32 and 126, continuation bytes are between 128 and 191, the initial byte of 2-byte chars is between 192 and 223, and the initial byte of 3-byte chars is between 224 and 239. this gives us a range of roughly 53k to 86k for 2-byte chars (which includes 119818/2=59909), and 83k to 130k for 3-byte chars (which includes 119818).

I'm more familiar with julia than matlab, so I searched for 3-byte possibilities over there:

julia> collect(reinterpret(reshape, Int64, findall(iszero, 
[[224+a 128+b 128+c]*[224+d;128+e;128+f])[1]-119818 for a=1:15,b=1:63,c=1:63,d=1:15,e=1:63,f=1:63])))
6×15056 Matrix{Int64}:
 14  13  15  14  13  14  13  15  14  13  15  …  13  13  13  13  13  13  13  13  13  13
 63  63  63  63  63  62  62  59  63  63  63     22  21  20  19  18  17  16  15  14  13
 63  63  62  63  63  63  63  62  63  63  58     54  55  56  57  58  59  60  61  62  63
 13  14  15  13  14  13  14  15  13  14  15     14  14  14  14  14  14  14  14  14  14
 63  63  59  62  62  63  63  63  61  61  61     63  63  63  63  63  63  63  63  63  63
 13  13  14  14  14  14  14  14  15  15  15  …  63  63  63  63  63  63  63  63  63  63
julia> filter(x->all(isprint.([x...])), 
[Char(ans[1,i]<<12+ans[2,i]<<6+ans[3,i])*Char(ans[4,i]<<12+ans[5,i]<<6+ans[6,i]) for i=1:15056])
8436-element Vector{String}:
"ᢾ콾"
...

after filtering down to only pairs of printable characters, we still have 8436 options. 446 pairs have at least one lowercase char, 272 have uppercase, 272 have a punctuation, and there's no digits. 24 pairs have no letters, 1100 have one letter. unicode range is 0x18be to 0xfffd, with more towards the end of the range; so it's mostly cjk and hangul. ended up picking
[224+15 128+60 128+58]*[224+2;128+38;128+58] = 119818
or
[FULLWIDTH LATIN CAPITAL LETTER Z]*[CIRCLE DIVIDED BY HORIZONTAL BAR AND TOP HALF DIVIDED BY VERTICAL BAR]'

Old answer:

'Ňل'*['ʕł']'

Try it online!

since my userid is even, I originally aimed for userid/2, looking for 2-byte unicode characters that work. since id/2 is closer to the boundary here, there are only 13 pretty pairs of characters which multiply to half of my userid, so you can see them all: (first four fit in ascii so are invalid, next four have unprintables, then there's some hebrew punctuation character that doesn't show up on stackexchange)

18×2 Matrix{Vector}:
 [69, 1545]   ['E', '؉']
 [73, 1541]   ['I', '\u605']
 [80, 344]    ['P', 'Ř']
 [88, 336]    ['X', 'Ő']
 [131, 1733]  ['\u83', 'ۅ']
 [133, 1731]  ['\u85', 'ۃ']
 [137, 851]   ['\u89', '͓']
 [147, 841]   ['\u93', '͉']
 [322, 1604]  ['ł', 'ل']
 [323, 1478]  ['Ń', '׆']
 [324, 1602]  ['ń', 'ق']
 [326, 1475]  ['ņ', '׃']
 [327, 661]   ['Ň', 'ʕ']
 [341, 647]   ['ŕ', 'ʇ']
 [449, 1102]  ['ǁ', 'ю']
 [462, 1089]  ['ǎ', 'с']
 [707, 1031]  ['˃', 'Ї']
 [711, 1027]  ['ˇ', 'Ѓ']

since a dot product is a linear operation, you can stick two pairs next to each other and they add together, so this solution is
[192+5 128+7]*[192+10;128+21] + [192+25 128+4]*[192+5;128+2]=59909+59909=119818

Deadfish~, 19 bytes

iiisdo{d}oo{iiiii}o

Try it online!

Slightly less boring version for 21 bytes, actually generates the number 80050 instead of printing digits separately:

iissisdddddds{dddd}io

Try it online!

Vanilla Deadfish, 25 bytes

iiisdoddddddddooiisiiisio

Try it online!

Python 3.8+, 71 68 bytes

s=str;print(int(s(a:=1*True)+s(b:=a+a)+s(a-a)+s(a)+s(a-a)+s(b*b+a)))

Uses a lot of trickery involving the walrus operator := that has been available in Python since version 3.8.

What I do here is construct a decimal string containing my user id ('120105') which I then convert to an integer using Python's int function.

Originally I had done this for 79 bytes

print(int((c:=str(a:=int(True)))+c+c+(d:=str(a-a))+(e:=c+d)+e+e+d+e+e+d+c,a+a))

which builds a binary string representation of my user id, and also uses the fact that int(True) == 1, however I realized that building a decimal representation would be shorter (although only by 8 bytes as it turns out, unless there are further golfs).

I could have done something like @AlbertLang did in their Python solution where I just print the ordinal value of the unicode character \u1D529, but I wanted to do something a bit more original.

R, 29 bytes

`+`=strtoi
"ajde"+("l"+pi^pi)

Attempt This Online!

My user ID is 101276. Converted to base-21 this will be AJDE, which contains no digits 0-9. Now to get 21 I am using the same base-conversion function strtoi with the arguments 'l' and \$π^π\$ which yields 36 (the decimal part is ignored).

R, 62 bytes

b=pi^pi
`^`=strtoi
format(as.Date('d'^b*'d'^b*'f'^b),'%d%m%y')

Attempt This Online!

The second - quite a long solution - outputs the UID as a date without delimiters (December 10th, 1976). The function as.Date receives 2535 as it's argument. Luckily, 2535 is a product of 13 * 13 * 15 and these numbers are obtained by base-36 conversion as shown above.

My id is 86147

Zsh, 12 bytes

Uninteresting answer: ##<CHAR> to get codepoint in arithmetic mode.

<<<$[##𕂃]

Try it online!

More interesting, a single # in arithmetic mode gets the codepoint of the first character of the variable which follows. Restricting ourselves to only using variables defined when the shell launches:

Zsh, 28 bytes

<<<$[#PS4+#PS4]${##}$[#HOME]

Try it online!

• PS4 defaults to +%N:%i>, so #PS4 is gets the codepoint of +, 43. 43 + 43 = 86.
• $# is the number of arguments passed to the script (0), ${##} is the length of that variable, 1.
• HOME should start with a /, codepoint 47.

Bash, 53 bytes

O=$(($$/$$));T=$((O+O+O));S=$((T+T+O));echo $S$S$S$T

J, 19 bytes

-:&.(a.&i.)@'fbrjn'

Try it online! (Link contains all snippets discussed in this answer, and more.) This was a fun challenge! I decided that all of my attempts should be verbs which take (and discard) one input and give constant output (either a number, or a string of digits).

My CodeGolf user ID, 31957, is cool because it's the 3428th prime number. Unfortunately, using this fact seems to be always longer than the simple approach presented here: Modifying the ASCII ordinates of a non-numeric string.

Explanation

u:inv can be used in place of a.&i. for the same byte count, but less interesting IMO. a.&i. is also useful in my alternatives, since it does not need a space after it.

-:&.(a.&i.)@'fbrjn'
           @'fbrjn'  using the string 'fbrjn' as input...
        i.           index of the input
     a.&             in the ASCII alphabet (equiv. 3&u: but without numbers)
                     ⇒ 102 98 114 106 110
-:                   halve each ASCII codepoint
                     ⇒ 51 49 57 53 55
  &.                 and then re-index the resulting numbers into the ASCII alphabet
                     ⇒ '31957'

Alternatives

While experimenting, I tried a lot of different approaches. I'd like to showcase a few.

33 bytes: The Q is superfluous, only included to make the length 3, which is a constant used a few times in the logic.

(' 'p:@".@-.~#}.#|.@":@u:])@'H+Q'
(                         )@'H+Q'  using 'H+Q' as input...
                #      u:]         get ASCII codepoints (equiv. 3 u: ])
                                   ⇒ 72 43 81
                    ":@            convert to string
                                   ⇒ '72 43 81'
                 |.@               reverse
                                   ⇒ '18 34 27'
             #}.                   chop off first 3 characters
                                   ⇒ '34 27'
 ' '      -.~                      remove spaces
                                   ⇒ '3427'
       ".@                         evaluate
                                   ⇒ 3427
    p:@                            prime index
                                   ⇒ 31957

29 bytes: Logically equivalent to prime(0xDAA - prime(prime(7)))

(p:@p:@>:@+:@#p:@-~dfh)@'daa'
(                     )@'daa'  using 'daa' as input...
                   dfh         convert from hex
                               ⇒ RHS: 3498
          +:@#                 double the length of 'daa'
       >:@                     and add one
                               ⇒ 7
    p:@                        prime index
                               ⇒ 19
 p:@                           prime index
                               ⇒ LHS: 71
                 -~            subtract LHS (71) from RHS (3498)
                               ⇒ 3427
              p:@              prime index
                               ⇒ 31957

26 bytes: Uses 31957^2 = 1021249849, and 1021249849 can be broken up into the ASCII codepoints 102 124 98 49 aka f|b1.

[:%:' '-.~&.":u:inv@'f|b1'
                   @'f|b1'  using 'f|b1' as input..
              u:inv         ASCII codepoints
                            ⇒ 102 124 98 49
            ":              convert to string
    ' '-.~                  remove spaces
          &.                and convert back to number
                            ⇒ 1021249849
[:%:                        sqrt
                            ⇒ 31957

25 bytes: Uses unprintables. ␀ corresponds to 0x00 (NUL) and ␛ to 0x1B (ESC). More direct encoding of prime(3427).

p:@(' '-.~&.":#u:])@'␀"␛'
                   @'␀"␛'  using '␀"␛' as input...
              #u:]         convert to ASCII ordinates
                           ⇒ 0 34 27
    ' '-.~&.":             remove spaces and reinterpret as number
                           ⇒ 3427
p:@(              )        prime index
                           ⇒ 31957

22 bytes:

(a.&i.u:@-#+#)@'=;C?A'
(            )@'=;C?A'  using '=;C?A' as input...
          #+#           length + length
                        ⇒ RHS: 10
 a.&i.                  ASCII ordinates
                        ⇒ LHS: 61 59 67 63 65
         -              subtract
                        ⇒ 51 49 57 53 55
      u:@               and convert back to ASCII
                        ⇒ '31957'

21 bytes: Uses an unprintable. ␄ corresponds to 0x04 (EOT). Logically equivalent to to_base([4, 70, 43], 3^2^2).

(*:@*:@##.#u:])@'␄F+'
(             )@'␄F+'  using '␄F+' as input...
          #u:]         ASCII ordinates
                       ⇒ RHS: 4 70 43
       #               length
    *:@                squared
 *:@                   squared
                       ⇒ LHS: 81
        #.             mixed base conversion
                       NB. 4,70,43₈₁ = 31957₁₀
                       ⇒ 31957

Wolfram Language (Mathematica), 35 bytes

(v=⌊E+E⌋)(p=Prime)@p@p[v!!+v v]

Try it online!

My user ID of 41105 is 5 times 8221. It so happens that the 40th prime is 173, and the 173rd prime is 1031, and the 1031st prime is 8221. The code exploits this coincidence.

The first part of the code takes the floor of e+e to get 5, sets v to that 5, and multiplies the automatically-returned 5 by the rest of the expression. The innermost part takes the double factorial of 5 to get 15, and adds that to the (implicit) product v v (25) for a sum of 40. The middle part sets p to be Prime, the nth prime function, and applies it three times to the number 40.

(My first serious attempt was 48 bytes.)

brainfuck, 27 bytes

-[----->+<]>--.++++..++++..

Output 15599. I am fortunate that my user ID is made of increasing digits. The initial loop sets a cell to ASCII 51 = 255/5 which is the character 3 So it would be even better if my user ID started with 3, but you can't have everything.

Try it online!

><>, 10 bytes

'ڹ+'a+*n;

Unfortunately, ord('5') is one of the two of my user ID's prime factors so I need an extra two bytes.

Equivalent to 1721 * (43 + 10)

><>, 11 byte

'눧눦'+n;

One char shorter at the cost of 1 byte.

Befunge, 7 bytes

"©H"..@

I welcome improvements on this to expand my knowledge...

Desmos, 29 bytes

Code pasted in is

f(x)=x¹¹⁹⁷⁰³
f'(lne)

You need to paste in the first line, then paste in the second line.

Try it online

R, 47 bytes

m=mtcars['Vo',]
f=m$cyl
m$hp*f*(f^f/m$carb-f/f)

Attempt This Online!

Built-in datasets to the rescue!

Uiua 0.17.0-dev.1, 10 bytes ^SBCS

/-"%÷η÷τ𝄐"

Try on Uiua Pad!

I decided I wanted to work within Uiua's SBCS, so this computes 117598 using only the values of Uiua+ASCII characters. /- is an alternating sum of the string, which works since Uiua treats characters as the null character plus their Unicode values.

Jelly, 3 bytes

⁽Be

Try it online! Answer kindly provided by @JonathanAllan.

Wolfram Language (Mathematica), 24 bytes (81203)

⌈°!E!/°^E/(Pi-°)⌉

Try it online!

Yes, ° is a number.

Google Sheets, 13 bytes

=CODE("𝞏")

46 bytes without CODE.

=LET(a,--TRUE,b,a+a,c,a+b*b+b,a&b&a-a&c&a&b+c)

31 bytes using ARABIC ^{credit to Squishalot}

=ARABIC("CXX")&ARABIC("DCCXIX")

TypeScript (TS type system), 101 88

type L<X>=X["length"]
type _=`${L<[,,,,,,,,,]>}${L<[,]>}${L<[,,,,]>}${L<[]>}${L<[,,,]>}`

Has errors, but type _ is "91403".

Perl 5, 16 bytes

say"@@@@@"^wrwvw

Try it online!

MATLAB / Octave, 22 bytes

disp(['SVSYX'-' ' ''])

Try it online!

Explanation

disp(['SVSYX'-' ' ''])

      'SVSYX'           % Row vector of chars
             -' '       % Subtract this char (space). Converts chars to codepoints
     [            '']   % Concatenate with empty string. Converts codepoints to chars
disp(                )  % Display

Tcl, 18 bytes, 16 chars

puts [scan 犍 %c]

Try it online!

PowerShell, 37 bytes

-join("`a",'S','_'|%{[byte][char]$_})

Try it online!

Not strictly a Unicode solution: takes the string representation of some ASCII codes; "`a" is the 'special' character in PS (Alert/Bell, 7)

Three more solutions more in the spirit of Steve's comment "I'd encourage people to also submit an alternative version that doesn't rely on simply decoding a unicode character"

PowerShell, 76 bytes

$o++
$f=$o+(++$o)*$o--
"$([math]::Cos(($o++-shl$f+$f+$f)-$f))"|% S*g(++$o)$f

Try it online!

The cosine of 32763 happens to be -0,783955601801536
This constructs a one, a five, shifts the 1 left by 15 bits, subtracts 5, takes the cosine, turns it into a string, and then invokes Substring(3, 5).

PowerShell, 80 bytes

$t++;$t++
$i=$t*$t*$t
-join$((--$i)
(++$i)
$i/=$t
(--$i)
($i*=$i)
$i++
($i/=$t))

Try it online!

Creates a 2 and then uses a variable to create the digits; the expressions in brackets will also be output, and then -joined to a single string.

PowerShell, 119 bytes

$p="$([math]::PI)"
$t++;$t++
$i=$p.Length
-join$($p[($i-=$t)]
$p[($i-=$t)]
$p[($i-=$t)]
$i-=$t
$p[($i-=$t)]
$p[(--$i)])

Try it online!

This iterates over the first few decimal places of Pi, which contains my user id backwards.

3.14159265358979
     ^^   ^ ^ ^ 

Red, 52 bytes

f: func[s][load debase s]prin rejoin[f"NzU="f"Njgx"]

Try it online!

The straightforward base64 encoding of "75681" contains digits - that's why I ended up joining the encodings of "75" and "681".

Python, 10 bytes

b"t".hex

Attempt This Online!

Creates and returns 101374 as a hex dump. Contains two unprintables.

Python, 23 bytes

-7 @xnor by printing directly avoiding string interpolation

print(*b'\n\rJ',sep='')

Attempt This Online!

Python, 30 bytes

print('%d%d%d'%((*b'\n\rJ',)))

Attempt This Online!

Writes 101374 by concatenating ASCII codes of \n,\r,J.

Or:

Python, 18 bytes (@xnor)

print(ord("𘯾"))

Attempt This Online!

Vyxal 3, 5 bytes

"ƛb④“

Vyxal It Online!

"ƛb④“ # push compressed integer 88192
#implicit print

ACCUMULATOR, 18 bytes

Expects no input.

AOOMOAAAAAAOAAORAO

Wolfram Language (Mathematica), 37 bytes

Prime[Fibonacci[(c=⌈Pi⌉)!-c]+c]+c

Try it online!

67961

JavaScript (V8), 27 bytes

o=>[E=-~-~!o]+~~o+(!o<<E*E)

Try it online!

Outputs 30512 as 3, 0, 1 << 9

Boring answer (18 bytes): '眰'.charCodeAt()

atob`MzA1MTI=`

Retina 0.8.2, 12 bytes

bhgac
T`l`d

Try it online! Explanation: Inserts the string constant bhgac, then transliterates the letters a-j into the digits 0-9.

Charcoal, 5 bytes

”)⧴¬#

Try it online! No verbose code because it prefers the string 17602 for some reason ;-) Explanation: Simply a "compressed" string.

I had tried a number of six-byte alternatives before discovering the above:

Ｉ⍘!z;γ

Converts the string !z; from base 95 to decimal.

Ｉ℅䓂

Converts the ordinal of that character (which unfortunately takes 4 bytes to encode in Charcoal) to decimal.

Ｉ¹⁷⁶⁰²

Converts the numeric constant 17602 to decimal.

JavaScript (ES6), 18 bytes

Suggested by @l4m2

Computes +0xe4c3 = 58563.

_=>+atob`MHhlNGMz`

Try it online!

JavaScript (ES6), 22 bytes

This computes \$58563=242^2-1\$, where \$242\$ can be converted to MjQy in base-64.

_=>(q=atob`MjQy`)*q+~_

Try it online!

This is 1 byte longer than ...

JavaScript (ES6), 21 bytes

... the boring answer.

_=>"".charCodeAt()

Try it online!

JavaScript (Node.js), 32 bytes

_=>[a=(b=-~-~!_)-~b]+~-a+b+~-b+b

Try it online!

Not assuming any char encoding

JavaScript (Node.js), 16 bytes

_=>atob`NzYzMjM`

Try it online!

Use base64. unicode would go longer so not here

Nekomata, 5 bytes

"Hᶜ"∏

Attempt This Online!

My user ID is 9288.

"Hᶜ"∏
"Hᶜ"    The string "Hᶜ" ([72, 129] in Nekomata's custom encoding)
    ∏   Product (72 * 129 = 9288)

APL+WIN, 16 bytes

⌽(⍕⎕av⍳']_')~' '

Obtains index positions of ]_ characters in the atomic vector, converts to characters, removes the space and reverses to give 6949

05AB1E, 3 bytes

ŽÍ¿

Try it online.

Simply uses the compressed 52210, which is output implicitly. 🤷

See this 05AB1E tip of mine (section How to compress large integers?) to understand how the compression works.

Ruby, 10 bytes

쯡 has character value 52194.

p'쯡'.ord

Attempt This Online!

Ruby 1.8, 21 bytes

print'fq'.to_i(?!),?^

My original answer, here just for posterity's sake cuz it was more creative.

fq is 521 in base 33. Since ! has a byte value of 33, we can access it with ?!. Same with ?^ for 94, combining into 52194. No longer works in Ruby 1.9+ because in that version ?x symbols give one-character strings instead of the character's byte value.

Vyxal 3, 4 bytes

Ꮠ≜ƛd

Vyxal It Online!

Same as my v2 answer, except 39425 can be compressed as Ꮠ≜ƛ for 3 bytes instead of 4

Vyxal, 5 bytes

»ṡṫ»d

Try it Online!

Outputs 78850 by doubling the compressed number 39425