text:
Without using numbers, get the highest salary you can. But don't exaggerate!
As I'm applying for some jobs whose job advert doesn't state the salary, I imagined a particularly evil interviewer that would give the candidate the possibility to decide their own salary ...by "golfing" it!
So it goes simply like that:

Without using numbers, write a code that outputs the annual salary you'd like to be offered.

However, being able to write concise code is a cornerstone of this company. So they have implemented a very tight seniority ladder where

employers that write code that is b bytes long can earn a maximum of ($1'000'000) · b−0.75.

we are looking at (these are the integer parts, just for display reasons):
   1 byte  → $1'000'000       15 bytes → $131'199
   2 bytes →   $594'603       20 bytes → $105'737
   3 bytes →   $438'691       30 bytes →  $78'011
   4 bytes →   $353'553       40 bytes →  $62'871
  10 bytes →   $177'827       50 bytes →  $53'182

The challenge
Write a program or function that takes no input and outputs a text containing a dollar sign ($, U+0024) and a decimal representation of a number (integer or real).

Your code cannot contain the characters 0123456789.

In the output:

There may optionally be a single space between the dollar sign and the number.

Trailing and leading white spaces and new lines are acceptable, but any other output is forbidden.

The number must be expressed as a decimal number using only the characters 0123456789.. This excludes the use of scientific notation.

Any number of decimal places are allowed.

An entry is valid if the value it outputs is not greater than ($1'000'000) · b−0.75, where b is the byte length of the source code.
Example output (the quotes should not be output)
"$ 428000"            good if code is not longer than 3 bytes
"$321023.32"          good if code is not longer than 4 bytes
"  $ 22155.0"         good if code is not longer than 160 bytes
"$ 92367.15 \n"       good if code is not longer than 23 bytes
"300000 $"            bad
" lorem $ 550612.89"  bad
"£109824"             bad
"$ -273256.21"        bad
"$2.448E5"            bad

The score
The value you output is your score! (Highest salary wins, of course.)

Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, $X (Y bytes)

where X is your salary and Y is the size of your submission. (The Y bytes can be anywhere in your answer.) If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
# Ruby, <s>$111111.111... (18 bytes)</s> <s>$111999 (17 bytes)</s> $123456 (16 bytes)

You can also make the language name a link, which will then show up in the leaderboard snippet:
# [><>](http://esolangs.org/wiki/Fish), $126,126 (13 bytes)

var QUESTION_ID=171168,OVERRIDE_USER=77736;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body.replace(/<(s|strike)>.*?<\/\1>/g,"");s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a1=r.match(SCORE_REG),a2=r.match(LANG_REG),a3=r.match(BYTES_REG);a1&&a2&&e.push({user:getAuthorName(s),size:a3?+a3[1]:0,score:+a1[1].replace(/[^\d.]/g,""),lang:a2[1],rawlang:(/<a/.test(a2[1])?jQuery(a2[1]).text():a2[1]).toLowerCase(),link:s.share_link})}),e.sort(function(e,s){var r=e.score,a=s.score;return a-r});var s={},r=1,a=null,n=1;e.forEach(function(e){e.score!=a&&(n=r),a=e.score,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.lang).replace("{{SCORE}}","$"+e.score.toFixed(2)).replace("{{SIZE}}",e.size||"?").replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);s[e.rawlang]=s[e.rawlang]||e});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var r=e.rawlang,a=s.rawlang;return r>a?1:r<a?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SCORE}}","$"+o.score.toFixed(2)).replace("{{SIZE}}",o.size||"?").replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var LANG_REG=/<h\d>\s*((?:[^\n,](?!\s*\(?\d+\s*bytes))*[^\s,:-])/,BYTES_REG=/(\d+)\s*(?:]+>|<\/a>)?\s*bytes/i,SCORE_REG=/\$\s*([\d',]+\.?\d*)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:520px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Score	Size

Winners by Language

Language	User	Score	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SCORE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SCORE}}	{{SIZE}}	Link

Edit: (rounded) maximum allowed score per byte count, for a quicker reference - text here:

This is one of the very few (imo) successful non-fixed-output no-input non-random challenge. Unique idea!

would $ 119 126 be valid output?

@ovs not according to the rules, no. sorry

Nice challenge! Can we output a fully formatted currency value, if desired? Like $80,662.67 instead of $80662.6659? Your rules seems to preclude the comma, which means I couldn't use any built-in currency functions.

I hope you don't mind, I've added a variation of the Leaderboard Snippet that sorts by score instead of bytes. Excellent first challenge!

Just noticed the new contributor tag. Well-constructed challenge, with such a high upvote and a vast amount of answers in only a few days, I wonder if this could be eligible for this years' Rookie of The Year ;)

I've nominated this challenge as a candidate for "Rookie of the Year - Challenges" category in Best of PPCG 2018 as I said back then.

Can I print something like "12.99919392382"?

@BgilMidol yes, any number of decimal digits is allowed, as long as there's a dollar sign (and an optional space) before that

bash, $127127
x;echo \$$?$?

Try it online!
Since the x command doesn't exist, it errors and sets the exit code to 127.
Then, the code outputs a dollar sign followed by $? twice. The $? variable stores the exit code of the previous command, so this outputs $127127 in 13 bytes.

Funnily enough if you're on Mac and you have XQuartz installed, this won't work because x does exist. As a bonus, it crashed when trying to open it, so I got $11 instead!

Use ] instead of x, the former is less likely to exist.

@numbermaniac Also, such commands were found for installing on ubuntu 19.04: e, q, r. But w is a thing (close to who) and exit successfully, so you get $00 for it!

Java 8, $131,199.00 (15 bytes)
v->"$"+'e'*'ԓ'

Try it online.
Explanation:
v->            // Method with empty unused parameter and String return-type
  "$"+         //  Return a dollar sign, concatted with:
      'e'*'ԓ'  //  131199 (101 * 1299)

\$131,199.00 < 131,199.31\$
I used a program to generate a printable ASCII character in the range [32, 126] which, when dividing 131199, would have the lowest amount of decimal values. Since 101 can divide 131199 evenly, resulting in 1299, I'm only 31 cents short of my maximum possible salary based on my byte-count of 15.

Dang, impressively efficient score!

... doesn't the program use numbers now after the edit, which is forbidden by the challenge?

@Laikoni Woops.. I'm an idiot -_-  Thanks, rolled back.

CJam, (5 bytes) $294204.018...
'$PB#

Try it online!
Explanation:
I derived it from Dennis' answer, but looked for combinations of numbers which would yield a higher result. I almost gave up, but I saw that P is the variable for \$\pi\$, and that \$\pi^{11} \approx 294000\$. The letter B has a value of 11 in CJam, giving the code above.

Since your score is your salary, you should mention it in the header. This answer is currently winning. :)

CJam, 5 bytes, $262'144
'$YI#

Try it online!
How it works
'$     Push '$'.
  Y    Push 2.
   I   Push 18.
    #  Pop 2 and 18 and perform exponentiation, pushing 262144.

R, 20 bytes, $103540.9
T=pi+pi;cat("$",T^T)

Try it online!
The max for 20 bytes is $105737.1, so this is quite close to the salary cap!
This would be a nice raise, and if I get paid to do code golf......

might be a way to combine pi with a dataset's sum... would require a programmatic approach to evaluate various combination of operators/datasets/pi to get as close to the max as possible. No time for this now but it sounds like a nice challenge in itself.

GS2, (5 bytes) $292,929
•$☺↔A

A full program (shown here using code-page 437). (Maximum achievable salary @ 5 bytes is $299069.75)
Try it online!
Builds upon Dennis's GS2 answer...
•$☺↔A                             []
•$    - push '$'                  ['$']
  ☺   - push unsigned byte:
   ↔  -   0x1d = 29               ['$',29]
    A - push top of stack twice   ['$',29,29,29]
      - implicit print            $292929

That's 11 bytes, even if it is 5 characters.

@dotancohen: 0x0724011d41 is 5 bytes by my count...

@eggyal: I missed the bit about code-page 437. Nice touch!

Dear down-voter, could I have some feedback please; I don't see what is incorrect, not useful, or unclear.

Self-modifying Brainfuck, 16 bytes, $124444
<.<++.+.++..../$

Try it online!

You didn't end up using the :, so you can remove it and add another + for $124444.

@Nitrodon Ah right, thanks.

After printing the 1, why not count to 3 and then print only 3s? You would save a byte and print a higher number.

@12431234123412341234123 You'd need to save two bytes. Otherwise, with 15 bytes, you're only allowed up to $131199, $133333 is too much.

R, 21 bytes $99649.9
cat("$",min(lynx^pi))

Try it online!
A different R approach - see also Giuseppe's answer
Very close to the maximum of $101937 for this bytecount.
Bonus: object.size()
R, 24 bytes $89096
cat("$",object.size(ls))

Try it online!
This is probably system-dependent, but when I ra this on TIO I got $89096 - close to the limit of 92223 for 24 bytes.

neat! I thought about trying to pick a good dataset but I can't figure out where to look to find them...I guess the datasets package makes a lot of sense.

@Giuseppe I'm just trying prod and sum randomly... but prod increases too fast !

sum(volcano) is 690907 but that would have to be about 1 byte to work, haha

Great idea using datasets !

@Giuseppe good catch I had completely overlooked that! duh.

@digEmAll another thing would be the quantile functions for common distributions...but I have not found a way to do it golfily. might not be such a good idea.

Other usable functions include sd and var but I did a quick brute force search on all the datasets and I didn't find any interesting "value"... but surely I missed something. The problem here is that cat("$",) leave us with 10 free characters at most, so a lot of datasets are unusable :(

@digEmAll Perhaps max?

I tried also max/min, but no single value is near 100K :( ... Another approach could be concatenating two numbers in cat, but that would require sep='' which takes other bytes...

You can try ^pi or *pi combined with sum, min, max for 3 lette dataset @digEmAll

There is only 1 letter dataset lh, and four 3-letters : BOD,co2,CO2,npk but 2 of them have numbers in the name. Also, npk contains factors so sum/max etc does not work. For BOD and lh I couldn't find any useful combination. (PS: probaly you know it but you can get all datasets names using ls("package:datasets") )

@digEmAll is there a way to print only the first decimal digits of pi (excluding 3)?

@JayCe: mmh, I'm not aware of any function doing that...

@digEmAll asking as I am really bad at sprintf, formatC, etc... I tried several ways but none worked

Let us continue this discussion in chat.

JavaScript (ES6), 19 bytes, $109,839
_=>atob`JDEwOTgzOQ`

Try it online!
\$109839\$ is the highest integer \$\le 109884\$ which does not produce any digit when prefixed with '$' and encoded in base64.

Without atob() (Node.js), 26 bytes, $86,126
_=>'$'+Buffer('V~').join``

Try it online!
The concatenation of '$' with the ASCII codes of 'V' (86) and '~' (126).

Wow Buffer. First time ever to acknowledge this class ;')

@user71546 It could be done in 24 bytes for $91,126 if thousand separators were allowed. But apparently, they're not... :(

Buffer constructor is deprecated, so that will get longer in future versions

@mcfedr We don't care for code golf, as long as a working version of the interpreter is properly specified.

PHP, $131116 (8 bytes)
Didn't see one for php and wanted to throw one up. I know someplace in php is a bad typecast that would cut this in half but I can't find it right now.
$<?=ERA;

This just takes advantage of PHP short tags and the PHP built in constants.
Try it online!

Ha I’ll switch it out for something else tomorrow

Instead of <?="$"., just do $<?= and save a few bytes.

@IsmaelMiguel nice thanks! Got it down to 8 bytes but didn't take long enough to figure out how to get the other ~70k of my salary.

That is quite a nice constant! Really wasn't aware of it. Also, it is usual to leave the old version, so people can still see it. But it is fine, you did a nice job!

@Arnauld thanks! I updated the link :)

Note that you can click on the 'Link' button in TIO and select 'Markdown' to get a link that can be pasted right away within the submission. Or even 'Code Golf submission' for a full TIO-based answer. Nice first answer, BTW!

wow didnt knew about this constant, but I couldnt find in docs, can any one help on this?

@Rafee it's actually not documented any place that I can find. It's a language constant that was added 17 years ago https://github.com/php/php-src/commit/f1364ebf3ead89f145af573e3b90f3503898b0ad. I found it by dumping all available constants and then just starting to grep for the shortest ones. It seems to be provided by the OS seen here https://www.gnu.org/software/libc/manual/pdf/libc.pdf on page 195.

I think that ERA might be for the Japanese Emperor era data, which is about to change at Q2 next year. The D_T/D/T format constants seem to suggest that.

GS2, 5 bytes, $291'000
•$☺↔∟

This is a CP437 representation of the binary source code.
Try it online!
How it works
•$     Push '$'.
  ☺↔   Push 29.
    ∟  Push 1000.

Excel  19 bytes $107899.616068361
="$"&CODE("(")^PI()

Explanation:
     CODE("(")        // find ASCII code of ( which is 40
              ^PI()   // raise to power of Pi  (40^3.141592654)
 "$"&                 // append $ to the front of it
=                     // set it to the cell value and display

Welcome to PPCG!

+1 Even better, they'll be impressed with your Excel skills and want you to be an account manager.

@theREALyumdub is that supposed to be a good thing? I'm not sure I'd take this salary if it means I have to work with Excel on the daily ;)

I'd argue with Excel's accounting formatting, that you can skip the $ entirely, and simply set the formatting to accounting.

@Selkie Accounting format adds a comma, which is disallowed.  You could use a custom format of $# though.  I wouldn't be sure if I should count this as 15 characters with =CODE("*")^PI() for $125773, or 17 characters (adding 2 for the the format letters) with =CODE(")")^PI() for $116603, or if this is disallowed.

="$"&UNICODE("") where the invalid character in there is U+1BF00. Counts as 2 bytes long so the total length is 18 bytes instead of 19 which raises the max salary to $114,432.

Jelly,  $256000 $256256  (6 bytes) $257256
⁹‘”$;;

A full program. (Maximum achievable salary @ 6 bytes is $260847.43)
Try it online!
How?
⁹‘”$;; - Main Link: no arguments
⁹      - Literal 256                            256
 ‘     - increment                              257
  ”$   - single '$' character                   '$'
    ;  - concatenate                            ['$',257]
     ; - concatenate                            ['$',257,256]
       - implicit print                      -> $257256

Previous...
5 bytes $256256
”$;⁹⁺

('$' concatenate 256, repeat 256 - causing interim implicit printing)
6 bytes $256000:
⁹×ȷṭ”$

(256 × 1000 ṭack '$')

That looks like 5 characters, but 11 bytes.

@dotancohen Jelly uses a custom code page.

@Carmeister:Nice!

$256512

@NieDzejkob indeed 6 bytes are available - I have $257256 now :)

vim, $99999 $110000 $120000
i$=&pvh*&ur

Try it online!
Uses the expression register (note that there is a <C-r> character, which is invisible in most fonts, between the $ and =, for a total of 13 bytes) to insert the value of the 'pvh' option times the value of the 'ur' option.
'previewheight' is the option that controls the height of preview windows, which is 12 by default.
'undoreload' is the maximum number of lines a buffer can have before vim gives up on storing it in memory for undo, and it defaults to 10,000.

C#
Full program, 72 bytes, $40448 66 bytes, $43008
class P{static void Main()=>System.Console.Write("$"+('T'<<'i'));}

Try it online!
Explanation
Left-shift operator treats chars 'T' and 'i' as integers 84 and 105 respectively and performs shift
Lambda, 19 bytes, $109568 17 bytes, $118784
o=>"$"+('t'<<'j')

Try it online!
Edit Thanks to @LegionMammal978 and @Kevin for saving 2 bytes

Just curious, why do you include a semicolon on the end of your lambda?

In addition to what @LegionMammal978 mentioned (trailing semi-colons doesn't have to be counted in the byte-count for Java/C# lambdas), by taking an unused empty parameter you can golf the ()=> to o=> for an additional -1 byte.

Indeed, with both @Kevin's and my advice, the lambda can be golfed to o=>"$"+('t'<<'j') with $118784.

@Kevin I didn't know about this, thanks for the info.

@LegionMammal978 Thanks for pointing out unnecessary semicolon and for providing updated lambda. I must have overlooked this semicolon somehow

However the question says it should take no input.

$"${'T'<<'i'}" would be equivalent also

PHP, 13 Bytes, $144000 Salary
Unfortunately for this job, moving to Mauritius is required (well, I could move slightly less far eastward, however every timezone less would yield at $36k drop in salary.) To compensate for the inconvenience, my salary increases by $1 every leap year.
$<?=date(ZL);

This just puts out Z the timezone in seconds and appends whether or not it's a leap year.

brainfuck, 43 bytes, $58888
++++++[>++++++<-]>.<++++[>++++<-]>+.+++....

Try it online!
How it works
++++++[>++++++<-]>.  write 36 to cell one and print (36 is ASCII for $)

<++++[>++++<-]>+.    add 17 to cell 1 and print (cell 1 is now 53, ASCII for 5)

+++....              add 3 to cell 1 and print 4 times (cell 1 is now 56, ASCII for 8)

Welcome to PPCG! Hope you stick around

Python 3, (22 bytes) $ 98,442
print('$',ord(''))

Try it online!
Much like Doorknob's Ruby answer, the 4 byte Unicode character used here, , has an ordinal value of the maximal integer salary achievable in 22 bytes.
Note that print() prints its unnamed arguments separated by spaces by default (sep is an optional named argument).

you can do slightly better than that using f strings: print(f"${ord('')}") is 21 bytes and outputs $101119

@Matt that is 24 bytes (I thought of f-string but realised that the extra braces would cost 2 bytes)

Proof that Python 2 will earn a higher salary.

Gol><>, $207680 in 8 bytes
'o**n; $

Try it online!
How it works:
'        Start string interpretation. Pushes the ASCII value of every character until it wraps back around to this character
 o       Output the top stack value as ASCII. This is the $ at the end of the code
  **     Multiply the top 3 stack values (This is the ASCII of 'n; ', 110*59*32
    n    Output top of stack as integer.
     ;   Terminate program
       $ (Not run, used for printing the $)

Interestingly enough, you can use h instead of n;, which yields 'o**h5$ with a score of $231504, but you can't use 0-9, and there isn't another 1-byte way to push 53, the ASCII value of 5

Welcome to PPCG!

05AB1E (5 bytes), $262626
'$₂ÐJ

Try it online!
\$262626 < 299069\$. Pushes the character $ to the stack, then pushes the integer \$26\$. From here, the program triplicates the integer, leaving the stack as ["$", 26, 26, 26] and joins (J) the stack.

Mathematica, 18 bytes, $107,163.49
$~Print~N[E^(E!E)]

Full program; run using MathematicaScipt -script. Outputs $107163.4882807548 followed by a trailing newline. I have verified that this is the highest-scoring solution of the form $~Print~N[expr] where expr is comprised of Pi, E, I, and +-* /()!.

What about I?

@user202729 Nope, doesn't help; any number that actually uses I and not just I I or I/I will generally have a + 0.*I tacked onto its N.

Very nice! I had gotten as far as "$"~Print~Exp[E!N@E] (which is the same length as "$"~Print~N[E^(E!E)]), but with the quotation marks around $, the output was just barely over the limit.

What I came up with was Print[$,N[Pi^(Pi*Pi)]], giving $80662.7. I tried various combinations of Pi, E, +, *, ^ (thought about I but didn't see any effective way to use it), but it never occurred to me to try !.

$~Print~⌈E^(E!E)⌉ with left and right ceiling characters with one character it would be little bit more and 17 bytes

@jaeyongsung Since ⌈ and ⌉ are respectively U+2308 and U+2309, your code would take 21 UTF-8 bytes or 34 UTF-16 bytes.

JavaScript (Node.js), 23 bytes, $65535
_=>"$"+ +(~~[]+`xFFFF`)

Try it online!
This is the best I can get without atob, though there is a large improvement space tbh
You know, having no short character to ascii conversion function sucks A LOT.
AFTER A WHOLE DAY
JavaScript (Node.js), 30 bytes, $78011
_=>"$"+``.codePointAt(![])

Try it online!
or: 29 bytes, $80020
_=>"$"+``.codePointAt(!_)

Where  is U+13894 INVALID CHARACTER
Oh String.codePointAt! I've just completely forgotten this!
A joke one (15B, $130000), not vaild at all but just for fun
_=>"$十三萬"

So, why not _=>"$⑮萬" ^_^

I'm laughing right now because I can understand the Chinese...

How about x1683F?

Simply using _=>"$"+parseInt('1V0I',36) is also higher than what you have so far, so you might want to add that one too. Too bad you can't convert base 64 to decimal in JavaScript...

@GustVanDeWal sadly you cannot use digits in the code.

Whoops! Seems like I had too little sleep :)

No argument for codePointAt needed

Jelly, 8 bytes, $210176.48625619375
⁽½"×½”$,

3535 (⁽½") multipli(×)ed by its sqrt (½).
Try it online!

Ruby, $119443
$><<?$<<?.ord

Try it online!
The maximum integer output for 17 bytes. The Unicode character is U+1D293, which is 119443 in hex.

If you want to take a chance, try the 10 byte $><<?$<<$$ on a long-running system.  Answers up to 177827 are valid.

I think you mean "in decimal," or at least there's some ambiguity.

brainfuck, 34 bytes, $69999
+[->-[---<]>-]>.[-->+++<]>.+++....

Try it online!
Explanation:
+[->-[---<]>-]>.   Generate and print 36 ($)
[-->+++<]>         Divide by 2 and multiply by 3 to get 54 (6)
          .        Print 6
           +++.... Print 9999

Perl 5.26.2, 12 bytes, $146002
say$]^"\x11\x0e\x01\x06"
Hex escapes only shown because ASCII control chars are filtered out.
Try it online!
You can get a bit more with different Perl versions, for example $155012 with 5.25.12.

Where's the dollar sign?

@Zaid The dollar sign comes XORing 0x35 (ASCII char 5 from the Perl version string in $]) with 0x11, resulting in 0x24 (ASCII char $).

Wait, this source does contain numbers — namely 0, 1, 6.

@hidefromkgb Hex escapes like \x11 are ASCII control chars in the actual code. Have a look at the TIO link.

MATLAB, 17 bytes, $112222
['$','..////'+pi]

Old answer:
['$','RRUUTR'-'!']

nice one to use the automatic conversion of the ascii code thanks to the +pi

e is not a builtin constant in matlab

MathGolf, $353535 (4 bytes)
'$W∙

Try it online!
Explanation
'$    Push "$"
  W   Push 35
   ∙  Triplicate top of stack

Disclaimer
This language was created after the posting of this question. While the language is a general language, it is designed with numerical questions in mind. It contains a lot of 1-byte number literals, and other nifty things for number-related questions. It is still a work in progress.

dc, $169169 10 bytes
Dd*d[$]nnn

Try it online!
This prints 13 (D) squared, twice

Japt, 5 bytes, $262144
'$+I³

Test it

Explanation
I is the Japt constant for 64, ³ cubes it and then '$+ concatenates that with the dollar symbol.

Glad I checked first. I was about to post "${I³

Cubix, $155088 (12 bytes)
*Ouo'ე'$/@

Try it online!
An interesting problem, was hoping to get this down to 7 or 8 bytes, but it proved difficult.  Pushes the ე and $ characters to the stack, outputs the $, multiples top of stack, outputs the number and halts.  Still hoping to find a lower byte option

Befunge-93, 9 bytes, $192448
a>$",**.@

Try it online!
Outputs $192448, just two dollars and nine cents short of the maximum. This even works as a polyglot with proper implementations of Befunge-98, where it doesn't even have to throw up an unrecognised instruction error!
Explanation:
a>$        Basically no-ops
   "       Wrapping string that pushes the code and a lot of spaces to the stack
    ,      Print the $
     **    Multiply the byte values of a, > and a space
           62*97*32 = 192448
       .@  Print the number and terminate

Befunge-98 (PyFunge), 8 bytes, $209728
$",**.q:

Try it online!
The character : has been computed using the following method:
>>> chr(int((1_000_000 * 8 ** -0.75) / (ord(' ') * ord('q'))))
':'

Using @ and f also works but gives only $208896.

PowerShell 5.1, $77126 $85184 $101101 $105105, 25 21 20 Bytes
"$"+($x=+'i'[""])+$x

or
+'i'['']|%{"$ $_$_"}

or
$x=+'i'[''];"`$$x$x"

+10k thanks to AdmBorkBork
+16k thanks to Mazzy
+4k thanks to Mazzy again
+2 solutions thanks to Mazzy, the absolute Maddest Lad
With a little help, we hit the 100k mark. We have "i" index into itself to do some cheeky casting and then concats that to itself.

You can golf some bytes (and thus improve the salary) using + instead of [int] like follows -- "`$$(+[char]"C")"+(+[char]'~')

Take it: "$"+($x=+'e'[+$i])+$x, $101101, 21 bytes. You should start the script on a clear Powershell with Set-StrictMode -Off (default mode). If $i have defined then clear the var by command rv i

Enjoy the bonus: "$"+($x=+'i'[""])+$x, $105105, 20 bytes

One more 20 bytes :) $x=+'i'[''];"``$$x$x". Note double used for comment on stackexchange only. Replace double on single one or use allowed space $x=+'i'[''];"$ $x$x".

Newerending story... +'i'['']|%{"$ $_$_"} with Scrooge McDuck emoji string $ $_$_

Excel VBA - 22 Bytes,  $97336
?"$"&Asc(".")^Asc("")

How it works
? - Print in immediate
 "$" - $ character
 asc(".") = 46
 Asc("") = 3
  46 ^ 3 = 97336

A good first post!  You can drop an extra byte by removing the &, but this doesn't open up any useable higher salaries via this method - only 10^5 = 100,000, which would require a line-feed, and then can't be typed in the immediate window (vbLf would take you over the character limit)

This a great first post, but it is worth noting that it only works in 32-Bit Versions of Excel, as in 64-Bit Versions, the ^ character plays double duty as both the exponentiation and longlong type declaration character

Hexagony, 12 bytes, $122122
D{y@!!<'*;z/

Try it online!

Jelly, 5 bytes, $256'256
”$¹⁹⁹

Try it online!
How it works
”$¹⁹⁹  Main link. No arguments.

”$     Set the left argument and the return value to '$'.
  ¹    Apply the identity function. This allows implicit printing.
   ⁹   Set the return value to 256.
       Since this discards the previous return value ('$'), it is printed implicitly.
    ⁹  Set the return value to 256.
       Since this discards the previous return value (256), it is printed implicitly.
       (implicit) Print the last return value (256).

Perl 6, 11 bytes, $165,000 10 bytes, $177,147 12 bytes, $150,000
'$'~㉝*ↁ
'$'~۳¹¹
{'$'~۳*ↇ}
Try it online!
The Unicode characters ㉝ (CIRCLED NUMBER THIRTY THREE) and ↁ (ROMAN NUMERAL FIVE THOUSAND) conveniently evaluate to their Unicode values in numeric expressions.
۳ is the Unicode character EXTENDED ARABIC-INDIC DIGIT THREE, which conveniently evaluates to its Unicode value of 3 in numeric expressions.  That 3 is raised to the eleventh power by following it with two superscript ones.

What about just 20000? Try it online!

Actually though, I think this is just a snippet, so you should make it a function or a full program. 162754

@JoKing Clearly I didn't search enough of the Unicode space to find that 200,000.  As for being a snippet, the question asked for "output," which I think can reasonably mean the result of evaluating an expression.  Also, at the time I answered, there were several other responses which were just expressions.

But since it's hardly a big deal...

162754

Swift, $131072 (13 bytes)
"$\(MAXPHYS)"

In Swift Playground it prints "$131072"

Welcome to PPCG!

APL $130189.4947846055 (18 15 bytes, 10 9 characters)
Thanks to @Ross Presser for pointing out the byte length and for saving a character. Byte length determined using Python's len function.
'$',!○*≡⍬
=> $ 130189.4947846055

Can be run on repl or offline if you have an APL interpreter e.g. NodeJS + NGN APL.
The maximum for the length is $177827.9.
How it works
⍬ is the empty vector and the single argument form of ≡ obtains the depth of the argument (number of nested arrays, effectively). This can be used to obtain the number 1 in order to perform further math operations, as a vector containing only scalars (or nothing at all) has depth 1.
!○* are the factorial, pi times X, and e^x functions, respectively. APL operates right-to-left, so the value 1 is passed to these functions RTL and this expression computes (pi * e)!.
Then the dollar sign must be prepended by concatenating (,) the string value with the computed value.
Note: I did this mostly by trial and error. Often, using exponentiation after multiplication resulted in values that were way too large for the byte count. There might be a more optimal combination of operators.

here's a permalink for your answer (although it only evaluates as an integer, which loses you 49 cents).  "10 bytes" is only accurate if you are using IBM Codepage 907.

And you can save a byte by doing simply ≡⍬ instead of ⍬≡⍬

><>, 7 bytes, $232110
'onnè$

Try it online!
Explanation (simple):
'onnè$
'      : Start putting chars onto the stack.
 o     : Print the stack top
  nn   : Print the stack top as numbers
    è$ : Errors the program

Haskell, $99999 (15 bytes)
pred<$>"%:::::"

Try it online!

T-SQL, $65,025 $72,614 (33 bytes)
PRINT CONCAT('$',CHECKSUM('
ßÝ'))                                       --  $72614,   33 bytes

Just in case that doesn't display or copy correctly, the string is CHAR(10) + CHAR(223) + CHAR(221), so does not contain any multi-byte characters.
I've verified CHECKSUM produces this same result in both SQL 2017 and SQL 2012; it is unlikely but possible that other versions might produce different values (since the exact CHECKSUM mechanism is unpublished).
To find this I had to evaluate the CHECKSUM of all possible 3-character strings from CHAR(9) (tab) to CHAR(255). Good thing that's easy enough to do in SQL with a self-join from a number table.
Some of my prior attempts:
PRINT CONCAT('$',CHECKSUM(']èÆ'))           --  $72562,   33 bytes
PRINT CONCAT('$',SQUARE(ASCII('ÿ')))        --  $65025,   36 bytes
PRINT CONCAT('$',PI()*EXP(PI()*PI()))       --  $60738.6, 37 bytes

Note that any of these can alternately be written, with no loss of bytes, as:
PRINT FORMAT(CHECKSUM(']èÆ'),'C')           --  $72,562.00  33 bytes

The latter has a more nicely formatted output, but it is unclear whether the comma is allowed by the rules.

Keg, $298298 (5 Bytes)
\$Ī:

Fixed my answer now so it actually fits within the rules. Ī is two bytes so this is very close to the max I can get for this byte count.
How it works
\$   Pushes $ to the stack, has to be escaped since $ is the swap instruction in Keg
Ī  Pushes the unicode value of this character, which is 298
:  Duplicates the top value of the stack, which is 298
End of programme prints entire stack, resulting in $298298

Ok, fixed all problems with it now

Oh, I was using Ī since it's Unicode value is 298, and not because it's an instruction. Also, any number above 255 is outputted as a number instead of a character, so it doesn't seem like undocumented behaviour

+1 for clever use of Unicode characters.

Hey @EdgyNerd, you are right about numbers greater than 255 being printed as integers not being undocumented behaviour: when creating the implicit output system, I wanted it to print only ASCII characters in the range of 10 to 255. Why? Because I had no clue people would be using Unicode characters. But also, I think it is unique as well.

yeah, using Unicode character allows you to represent large number using very little bytes, and, as you said, I don't think any other lang has a feature like that

Python (28 bytes; $15876)
print('$',ord('~')*ord('~'))

Try it online!

This is my first code golf answer. :)

Welcome to Code Golf, and nice first answer! Be sure to check out Tips for golfing in Python to maybe help golf your code.

vemf, $200,000 (7 bytes) $210,000 (8 bytes)
+1 byte but also +$10,000 thanks to Julian
hhg+ª;`$

try it online
Explanation
     ;   ' procatenate (reverse concatenate)
    ª    '   string representation of
hhg+     '     210,000 (as 100,000+100,000+10,000)
         ' and
      `  '   character literal
       $ '     dollar sign

Nice answer! However the 2 in your answer does not match the rule "Your code cannot contain the characters 0123456789." ?

h;+ª;`$ seems to get the same result for the same byte count

You can even get $10,000 extra this way hhg+ª;`$

ahhh darn the 2

Brain-Flak, $55555
([(((()()()()){}){}())](((((({})({}()){}))))))

Try it online!
Brain-Flak with -r flag, $57777
((((((((()()()()){}){}())(({}()){}))()()))))

Try it online!

Pascal (FPC), $72089
33 bytes
begin write('$',$AFFFF div$A)end.

Try it online!
Found by playing with arithmetics and hexadecimal constants. See below for more interesting answers.

Pascal (FPC), $65526
37 bytes
var x:word=-$A;begin write('$',x)end.

Try it online!
Thanks to @JonathanAllan for reminding me of initialization in declaration, it shortened my new approach.
No way Brain-Flak programmer can have bigger salary!
$A is hexadecimal constant 10. Variables of type word have values in range 0..65535, so initializing it with -10 gives 65526 instead (and a range check warning).

Pascal (FPC), $54872
47 bytes
begin write('$',ord('&')*ord('&')*ord('&'))end.

Try it online!

var x:byte=ord('&');begin write('$',x*x*x)end. saves a byte, but does not increase salary.

Java
program, 73 bytes, $40033 (of max 40041.67)
interface G{static void main(String[]a){System.out.print("$"+'+'*'Σ');}}

Explanation
It uses the product of the ascii character + (43) with the greek unicode character Σ (931).
Lambda, 35 bytes, $69388 (of max 69494.27)
()->System.out.print("$"+'L'*'Α');

It shouldn't change your solution much, but the required format is dollar sign first, then value

Bubblegum, $260847 (6 bytes)
00000000: 03b3 c759 0bf8                           ...Y..

Try it online!

dc, $177147 (9 bytes)
[$]nAvB^n

Try it online!
\$\lfloor\sqrt{10}\rfloor^{11}\$.

><>, 8 bytes, $210196
'o+n+|V$

Try it online!
Explanation:
'         Push the rest of the code to the stack
 o        Print the $
  +n      Add the top two and print as a number (210)
   n+|    Add the top three and print as a number (196)
 o+       Error as the stack runs out

PHP, 18 bytes, $114431
This was actually a very quick challenge, but fun!
$<?=ppuurp^AAAAAA;

Simply writes $114431 (excluding the warnings).
Tricks I've used:

PHP will output anything outside it's opening and closing tag (saves 3 bytes vs '$'.[...])
The opening tag <?= has the same effect as <?php echo [....]; (saves 8 bytes)
You don't need to use quotes for "strings" that don't have spaces or start with numbers.
This makes it so PHP parses it as a constant.
Non-existing constants are converted to string (ex. AAAAAA is the same as "AAAAAA").
(saves 4 bytes - 2 bytes per "string")
You don't really need the closing tag, and PHP advices you to not include it if it is a page that shouldn't have output.
(Check https://stackoverflow.com/a/19953547/2729937 for more).

Shakespeare Programming Language, $18000 (207 205 bytes)
,.Ajax,.Ford,.Act I:.Scene I:.[Enter Ajax and Ford]Ajax:You be the square oftwice the sum ofa cat a big cat.Speak thy.You cat.Open heart.You be the cube oftwice twice the sum ofyou a big big cat.Open heart

Try it online!
This language made this challenge simultaneously easy and hard. On one hand, there already are no numbers in the source code. On the other hand, the program size can get VERY long (the shortest header is 51 bytes, meaning I'm already out $947601.07!).
Salary printed: $18000
Maximum salary: $18457.99 (rounded)

I believe your score is the number you printed, not the maximum salary. Interesting answer!

Thanks. I literally print $, 1, and then 8000.

$20736

How do you always do better than me? Clever use of the ASCII value of the dollar sign!

PowerShell, $1, 17 bytes
Owner's salary:
"$"+[bigint]::One

Try it online!

You could do "$"+[bigint]::One+[bigint]::One+[bigint]::One+[bigint]::One+[bigint]::One and get $11111, keeping you below the limit.

**An entry is valid if** the value it outputs is not greater than ($1'000'000) · *b*-0.75 Why would the owner break the rules? :)

Thanks for TIO link. I have the error This site can’t be reached with this site

O, Powershell syntax highlighting! Thanks!

maybe I'm missing something, but the length of what I posted above is 73 bytes, giving a maximum allowed salary of $40041.

Yeah, It's Owner's salary. :) It's reguired [bigint] to write his salary

LOLCODE 1.2, 19 77 Bytes ($38100)
HAI 1.2
    VISIBLE "$:[DIGIT THREE]:[DIGIT EIGHT]:[DIGIT ONE]:[DIGIT ZERO]:[DIGIT ZERO]"
KTHXBYE

Try it online!
The header HAI 1.2 and footer KTHXBYE are always required so not included in final byte count.
LOLCODE lacks a way to directly cast a char literal to a number, but you CAN give it a unicode normative name and it returns that unicode character. Changing the number name frequently changed the byte count so this was a bit tricky but this worked out fine :)
(Also had brainfart and forgot including 0123456789 wasn't allowed hence the 19 → 77. ^^;)

GolfScript, $210210 (8 bytes)
"$i").+.

Try it online!
"$i"     # Push this string
    )    # Separate last char and parse it to an integer, in this case it's 105
     .+  # Add it to itself
       . # Copy top of stack

In the end everything in the stack is concatenated. This is only $ 14.10 under the limit.

Hexagony, 15 bytes, $125125
j{F)))<'-;z/@!!

   j { F
  ) ) ) <
 ' - ; z /
  @ ! ! .
   . . .

I originally had an answer similar to @user202729, but I realized that I could add 3 increments ")" to z in order to make it 125 and it kept it under 16 bytes ($125000 max).
Try it online!

gvm (commit 2612106) bytecode, 7 bytes ($232255)
░$áΦá └
program shown in cp 437 encoding. It seems I can't paste a non-breaking space correctly here :( (ff in cp-437, U+00a0 in unicode) -- the space in the code should be one.
Output:
> ./gvm salary.bin
$232255

Hexdump:
> hexdump -C salary.bin
00000000  b0 24 a0 e8 a0 ff c0                              |.$.....|
00000007

Disassembled:
c:0100  b0 24       WCH #'$'    ; write character $
c:0102  a0 e8       WUD #$e8    ; write unsigned byte $e8 (232)
c:0104  a0 ff       WUD #$ff    ; write unsigned byte $ff (255)
c:0106  c0          HLT         ; terminate

This is a pre-alpha version of a virtual machine I'm working on -- hope this is still allowed, the commit that correctly executes this code is from yesterday :)

Japt, 7 bytes, $232,255
'$+#è#ÿ

Try it online!

Same idea I had. The byte count on TIO is wrong, though, it's actually 9 bytes. The highest you can manage in 7 is 232256.

@Shaggy didnt notice, couldnt get 232256 though

Sorry, that was a typo; should've been 232255.

@Shaggy The byte count is correct in Japt’s native ISO-8859-1 encoding.

Charcoal, 6 bytes, $252525
$×³Ｉ²⁵

Try it online! Link is to verbose version of code. Works by casting the numeric constant 25 to string and repeating it 3 times. The best Charcoal can do in 5 bytes is $222222:
$×⁶Ｉ²

Try it online! Link is to verbose version of code.

:( so close

LOWER, $40457
72 bytes
ₔₓ₃₆ₔₓ₅₂ₔₓ₄₈ₔₓ₅₂ₔₓ₅₃ₔₓ₅₅

Try it online!
ₔₓ<num> - print a character with ASCII code <num>

><>, 8 bytes ($196196)
code:
e|noi:*

input:
$

Try it online!
My first ever ><> entry; ><> is a weird language and it took me a while to find a way to print the $ without using a ton of characters. If it wasn't needed, f|n:* would print 225225 inside the $299069 limit. Instead, stuck with 8 characters and a $210224 limit. But hey, $196196/yr. is some serious money.
How it works
 e|noi:*
>          Fish starts top left, pointing right
 e         Push 14 onto the stack (stack: [14])
  |        Mirror. Fish is now moving left
 e         Push 14 onto the stack again, wrap around (stack: [14,14])
       *   Pop x and y, multiply, push result (stack: [196])
      :    Duplicate top of the stack (stack: [196,196])
     i     Read a character from input as a string ($), push to stack (stack: ['$',196,196])
    o      Pop and print it as a character (output `$`, stack: [196,196])
   n       Pop and print as a number (output `$196`, stack: [196])
  |        Mirror. Fish is now moving right
   n       Pop and print as a number (output `$196196` stack: [])
    o      Pop, stack is empty: error; program terminates

Challenge said no input... Nice language, still.

@StéphaneGourichon Oh shoot! :\

Revisted this a couple times and the best I can get without input is e6|n:*o*} (9 char, $196196 and too high). Managed an 8-char, but c3*:|no* only returns $129636 which is a third lower.

Pepe, $74088 (30 bytes)
reeeEeeEeerEeeEeEeEerEeeEereEE

Try it online!
Explanation
reeeEeeEee                     # print $
          rEeeEeEeEe           # push 42 in stack r
                    rEeeEe     # cube of 42 (74088)
                          reEE # output number

Actually, 8 bytes, $196418
'←┘F$'$+

Explanation:
'←┘F$'$+
'←        push the string "←"
  ┘       CP437 ordinal (27)
   F      27th Fibonacci number (F(27) = 196418)
    $     convert to string
     '$+  prepend a dollar sign

Try it online!

brainfuck, 30 bytes, $77'777
-[[<->->+>++++<<]>-]>.<<<.....

BF-Crunch did most of the work for me.
Try it online!

ShinyLisp, 8 bytes, $204864
S"$"DpEv

Ungolfed:
(strings "$" drop even)

drop is a function which discards the first few elements of a list. When used as a number, it's equal to 2048. even checks whether a number is even, but when used as a number, it's equal to 64. strings concatenates strings, so the two functions get cast to numbers which then get cast to strings.

MATLAB, 22 bytes, $99649.9031
['$',num2str(''''^pi)]

$99649.9031

Just bad luck the character ' is part of the syntax so to escape it I needed to repeat it.
This solution and all the other below are interchangeable with the sprintf function. Ex sprintf('$%f',''''^pi) will return the same output.

Older solutions:
23 bytes, $80662.6659
['$',num2str(pi^pi^pi)]

$80662.6659

24 bytes, $74704.2869
['$',num2str(now/pi/pi)]

$74704.287

Explanation:
the now function return a serial date code (today 29-August-2018 => 737301). Just needed to divide that a bit to make the salary fit the cap.
Nice thing about it, if you run it tomorrow you'll get a bit more (pennies only though...)

C, $80010 (29 bytes)
o(){printf("$%d",'\aq'*'*');}

Try it online!
I did a brute-force search on all expressions x * y, where x is a 2-character literal and y is a char. The desired result has a rather uncomfortable value, which requires one of the chars to be escaped: \a (which is equal to 7).
For a 29-byte program, the maximum that may be displayed is 80020.

Fun fact: my search program printed all solutions literally at first. Imagine what it did when it output all these \a characters...

You don’t have to escape that. And why not use a 3-character literal?

No real reason to avoid these literals, other than them being ugly. You might want to post your solution, because it's different/better than mine.

Do the rules allow you to skip main? This code doesn't compile...

Befunge-93, $154836 $164220 $165554, 12 11 bytes
".;=$",**.@

Try it online!
I calculated the Number using the ASCII Values of the letters
46 * 59 * 61 = 165554

Thanks to Jo King for golfing 1 byte and raising my salary by $9384 $10718.

@JoKing Thank you, I think the code is now only improvable by changing the ASCII Characters, but I haven't found a better combination yet.

6 dollars off the max

Excel: 23 bytes, $93648.047476083
="$"&PI()^(ARABIC("X"))

Max is $95214.73 (2 bytes can be saved, but no salary improvement by removing parentheses around the ARABIC function)
Excel: 15 bytes, $131196.0508, Max $131,199 (Cheat)
="$"&NOW()*PI()

For certain values of now() :-) (Set system date to 5/2/2014)

K (oK), $130,331.00 of a maximum of $131,199.00 (15 bytes)
"$",$*/`i$"//;"

Try it online!
Output contains quotation marks because that's how strings are represented in K.
How:
"$",$*/`i$"//;" # Anonymous function, no arguments.
          "//;" # The string '//;'
       `i$      # coerce into integers (uses the ascii values of '//;', which are 47 47 59)
     */         # product of the list (47² × 59 = 130.331)
    $           # convert into a string
   ,            # and prepend
"$"             # a dollar sign

You might want to change your decimal format to US instead of Europe (commas as thousand separator and dots as decimal separator). The leader-board in the question currently shows your answer at the bottom with $130.33.. ;) Nice answer though, +1 from me!

@KevinCruijssen just did that, thanks!

You don't need to cast it, "$",$*/"//;" works just as well and puts you at a higher cap

Python 2 (Cython), $101106 $101937 $105737 (21 20 bytes)
Another Unicode character solution. This is the closest printable character I could find to the 21-byte maximum amount. Don't think Python can get any higher than this...
print"$",ord("")

Outputs:
$ 105737

How it works
"" is 4-byte char U+18AF2 "TANGUT COMPONENT-755". 0x18af2 = 101106 in decimal.
Edit: Thanks to Dennis for pointing out that there's a usable character with a higher value and earning more money!
"" is 4-byte char U+18E31. 0x18e31 = 101937 in decimal.
Edit: Thanks to ovs for pointing out that the u prefix isn't necessary in Cython! An extra byte is gained: TIO
"" U+19D09. 0x19d09 = 105737.
NOTE: this works in TIO but fails in Python console with TypeError: ord() expected a character, but string of length 4 found

You don't have to use printable characters; U+18E31 will work just as well. Try it online! (using Cython because CPython would require a magic comment)

Oh that's great, thank you! In charmap there was a big gap after U+18AF2, thought it was a reserved area, but must have been the font I was using.

With Cython you don't seem to need the u, so you can go a bit higher.

thanks @ovs! I've just updated the answer. It feels a bit like cheating now it doesn't work in the Python console, but it's an extra $3800 so I don't mind :-D

Stax, 6 bytes ($256256)
¥r○s╙$

Run and debug it
Unpacked version:
VB$c'$L Full program
VB$     Push "256"
   c    Copy
    '$  Push "$"
      L Listify stack, producing ["$", "256", "256"]
        Implicit flatten and output

Braingolf, 8 bytes, $209,764
#$@#å+*

Output:
$209764

209764 < 1e6 * 8-0.75
Try it online!

nice to see somebody else using braingolf!

#$!@**8/ gives $209952 in the same number of bytes by doing (36^2)^2 / 8

K (oK), 13 bytes, $145794
Try it online!
"$",$*/"B//"

Run multiplication over the characters B//, it will convert them to their integer counterparts and give the result of B*/*/ (145794), String the result ($) and join (,) it to "$"

Gol><>, $232104 (7 bytes)
$'onhè

Well, I don't think this can get much smaller or higher in price! (and I know that the last char is a 2 byte char, I included it in the byte count)
There is a program that outputs a higher price, but it uses an error, in ><>, here is a link, which also works in Gol><> too!
5th version, $210104 (8 bytes)
$'ofe*nh

Only 120.1$ off from being the max score, whew!
4th version, $182182 in 9 bytes
$'oed*:nh

3rd version, $168168 in 11 bytes
'$'oce*:nn;

2nd version, $150150 in 12 bytes
'%'Moaf*:nn;

Literally 2 minutes after I made the previous one, I figured out how to golf it more.
1st version, $121121, 14 bytes
d:+a+ob:*:n:n;

|
|
|
Yep, that's it.
This can probably be golfed better with more money.

Zsh, $127569, 15 bytes
];<<<\$$?${-%?}

Try it online!
Squeezing out a bit more than the Bash answer by abusing the default flags. By default, the $- parameter is set to 569X. ${ %?} removes the last character.  We can actually get a lot further by manually controlling the flags:
zsh -178, $156789, 11 bytes
<<<\$${-%?}

Try it online!

If the exponent was slightly more favorable (-0.74 instead of -0.75), I could get quite the bonus: zsh +X5 -2378 '<<<\$$-' (7 bytes and $236789). Maybe management could be convinced next year...

I believe command-line arguments are included in the byte count. Good answer, though!

@PurpleP I like the reasoning of this meta post, but feel free to draw your own conclusions. :P

C# 29 20 19 Bytes
Assuming it's allowed to omit the otherwise required Main() entry point and assuming using System;...
Swapped to the interactive C# compiler and have saved now 10 bytes - 8 from removing Console and another by using an ascii character instead. And since it's the only line a semicolon isn't necessary. Not a bad salary :P
Write("$"+'Ϩ'*'m');

Output: $109000
Try it online!

Hexagony, $220220, 7 bytes
Ü~;]!@

Try it online!
This is my first Hexagony answer using []. This instruction switches between pointers and I've never really needed them before. Formatted, this is a size 2 hexagon.
 Ü ~
; ] !
 @ .

The Ü character has ordinal value 220, and we then negate that and output. (-220)%256 = 36, the ordinal value of $. Next we need to negate it back to 220, print twice and exit. However, if we implement this naively (just ~!!@), then that totals up to 8 bytes, which brings us over the $210224 limit. Instead we switch to the next pointer, which starts at the top right moving southeast. This executes the ~!, before wrapping round to the center, which pushes the value of Ü again, before switching again. Now we're on the right corner going southwest, printing again before wrapping around to the the center, negating and switching. Finally, we're in the bottom right moving west, which takes us to the @ to terminate.
To help visualise this, you can use the excellent Hexagony IDE at hexagony.net

Nibbles, $300000 (4.5 bytes)
"$"++;*;$

Attempt This Online!
"$"++;*;$
"$"       "$"
   +      Add
    +      add
     ;      x :=
      *      multiply
       ;$     1000
              100
            x
           x

This assumes that we don't have to round up fractional byte counts. Another solution which works without this assumption:
Nibbles, $256256 (5.5 bytes)
"$"*+;$~ch~

Attempt This Online!
"$"*+;$~ch~
"$"         "$"
   *        Multiply
    +  ~     add 1
     ;$       1000
        ch~  256

Vyxal, $177827 (10 bytes) $192450 (9 bytes) $210224 (8 bytes)
Thanks to Kevin Cruijssen for -1 byte and me for -1 byte
\$»∧<i»J

Run it
Explanation:
\$       # Push a dollar sign
  »∧<i»  # Push salary (base-255-compressed)
       J # Concatenate
         # Implicit print

You can go to 9 bytes and $192,450.00 by replacing the ₴ and , with a single trailing J (merge two items together & implicit output the result). :) Try it online. Maybe even 8  bytes is possible if there is a join flag in Vyxal?

Just got down to 8 bytes by compressing 210224 into base-255.

@KevinCruijssen I would have to include that flag in the byte count anyways.

Program flags are simply considered as different languages instead of counting towards the byte-count (since 2017). So in Vyxal this would be 8 bytes, but in (for example) Vyxal S this would be 7 bytes (S is the flag to join by spaces, but unfortunately it puts spaces between the digits instead of between the $  and number. I'm not sure if there is a flag to just output the joined result without delimiter.)

Aheui (esotope), 24 bytes, $91300
븖븜뜨쁘멓희다멍

Try it online!
Turned out to be surprisingly close to the bound of $92223.
밞밤따빠맣    9 4 * dup putchar; prints '$' (36) and leaves 36 on the stack
빠따밤밞      dup * 4 9; [1296 4 9]
망더          loop: print +; print 9, add, print 1300, break
희            halt

Thunno 2 j, 5 bytes, $262,144
kk³'$

Maximum for 5 bytes is $299,069
Explanation
kk      # Push 64 to the stack
  ³     # Pop and push 64 ** 3
   '$  '# Push the string "$"
        # The j flag joins the stack
        # (which is reversed in Thunno 2)
        # Implicit output

Screenshot

The first two answers violate the “no numbers” restriction. I’d think the third one is okay, though, because ³ isn’t 3.

@Bbrk24 oops, didn't see the "no numbers" rule in my rush to answer. Thanks for pointing it out.

Vyxal RssṪ, 26 bitsv1, 3.25 bytes ($371091)
\$»*

Try it Online!
If the interviewer is going to play dirty, then so am I. That'll teach companies to put arbitrary restrictions on their job offerings!

SmileBASIC, 10 bytes, $131072
?"$";#R*#L

#R and #L are constants with values of 512 and 256.

Forth (gforth), $104857 $125000 (16 bytes)
." $"char  .

Try it online!

+1 I feel silly for only now realizing that you don't need a space after the closing " to a ." word

GS2, 4 bytes ($256256)
•$▼▼

Try it online!
Just thought I'd add this as there were no 4 byte solutions. There are probably better solutions of 4 bytes, it'd be interesting to see what the highest is.
Explanation:
•$    Push a '$' character on the stack
  ▼   Push 256 on the stack
   ▼  Push 256 on the stack

Does GS2 use its own encoding table? If not ▼ doesn't seem like a single byte but 4, so the length of your code would be 10 bytes. Please correct me if I'm wrong.

@Skillmon this is actually the first program I've written in GS2. From the other answers, it seems like tio.run uses code page 437 (which is linked in other answers). From there I checked the docs to find the appropriate bytes and got this.

SQLite, 26 bytes, $86850
select'$'||unicode('')

Try it online!
Inspired by T-SQL @BradC answer

FreeBASIC, $124095 (16 bytes)
?"$" &&hc &&hfff

prints
$124095

? means print
&h is the hex prefix
& connects parts together
Tested using FreeBASIC online

VBA, 21 bytes, $101,126
Max salary for 21 bytes: $101937.86
?"$"ASC("e")&ASC("~")

Literally just prints $, 101 and 126 without spaces
Golfing wise:  VBA will automatically concatenate a string followed by a number or function, so there is no & required between ?"$" and ASC("e")
If the & is omitted, then you get spaces between the strings and numbers - if this is a valid output then for 20 bytes you can use ?"$"ASC("i")ASC("~") to get $ 105  126 (max salary: $105,737.13)

You could just use ÿ to get a slightly higher salary.
?"$"ASC("e")&ASC("ÿ") $101255

Common Lisp, $72447 (33 bytes)
(format t"$~d"(char-code #\))

The character is Unicode U+11AFF.
Try it online!

Pyth, $161051 (11 bytes) $192450 (9 bytes)
+\$C"ˮǂ

Performs an integer conversion (via C) on two two-byte characters (ˮ, code point 0x2EE, and ǂ, code point 0x1C2), resulting in a final value of 0x2EFC2, i.e. $192450, the best integer score for this byte-count.
Old answer:
+\$^hT/ThhZ

Prepends a '$' sign to the result of 11^5.

Excel, 10 16 bytes, $177827 $125000
="$"&ROW()
Not sure if this is a valid entry. It returns $ following the current row number. So if you put it on row 177827 125000, it will return  $177827$125000

As the number of digits in the number are the same length as the formula: &ROW() | 177827, you could just replace it to ="$177827" for the same bytes but doesn't require getting to row 177,827.

Indeed, but the rules state that I cannot use numbers :)

I've been awake for far too long, completely forgot the challenge rules. I guess I shall leave my comment so people can see my idiocy. lol

I’m pretty sure the row number needs to be included in the byte count when used in this way, per this standard loophole, so this is 16 bytes, not 10.

Got it. What is the correct course of action in this case? Do I delete my answer or edit it to be 16 bytes(Or less, considering I have to use the byte limitation of the question)?

As far as I can tell, the consensus is that using this kind of extra information is fine as long as it’s included in the byte count, so I’d just recommend editing to count the row number as 6 extra bytes.

x86 (32-bit) machine code, $124124
Hexdump (16 bytes):
b8 3a 1d e3 03 f7 e0 89 01 c1 e8 08 89 41 04 c3

Disassembly:
b8 3a 1d e3 03  mov eax, 65215802
f7 e0           mul eax
89 01           mov[ecx], eax
c1 e8 08        shr eax, 8
89 41 04        mov[ecx + 4], eax
c3              ret

I found the "magic" number 65215802 by brute-force search. Its square is hexadecimal F1C2C34323124. When interpreted as a 4-byte string, it's $124. After a shift by 8 bits right, it's 124, with a zero-byte string terminator.
For a 16-byte program, the maximum that may be displayed is $125000.

Flobnar, 16 bytes, $123904
$,g<+<>!
@X:+<*\

Try it online!
A little hard since I couldn't use numbers, but I got around it by using the get command.
Explanation:
........   Start the program
@......    Evaluate left and print result

......>.   Evaluate to the right
......\

$......!  Invert
.......   Pop the top of the call stack (does nothing)

$,g.....  Print the cell at:
..:....     Top of the call stack (0,0 => $)

.,.....!  , returns 0, ! inverts that to 1 and
......\     \ stores it in the call stack

...<+<..  Return ((Z+Z)+(Z+Z))*((Z+Z)+(Z+Z))
...+<*.     Where Z is the return of the leftmost arrow

..g.....  Return the cell at:
.X:....     Top of the call stack (1,1 => X (88))

Python 2, $65536 (34 bytes)
An answer using mathematical operators:
t=True;t+=t;t<<=t;print"$",t**t>>t

How it works
t=True;    # True evaluates to 1
t+=t;      # 1 + 1 = 2
t<<=t;     # 2 << 2 = 8
print"$",  # Python 2's print statement doesn't need parentheses or whitespace
t**t>>t    # 8 ** 8 = 16777216
           # 16777216 >> 8 = 65536

MATL, 12 bytes, $155052
'$'t';I'hpVh

(Maximum for 12 bytes is $155100)
Explanation:
'$'t';I'hpVh

'$'             String literal
   t            Duplicate
    ';I'        String literal, product of which results in highest bound by $_max / 38
        h       Horizontal concat
         p      Product (implicitly converts to int)
          V     Convert to string
           h    Horizontal concat

JavaScript, 31 bytes, $74088
(x='*'.charCodeAt())=>'$'+x*x*x

The * asterisk character decimal code point 42 cubed is 74088 Try it online!

Common Lisp, 59 bytes $46974
(defun x()(format nil "~{~a~}"(list'"$"(char-code #\띾))))

Try it online!

Runic Enchantments, 6 bytes, $255000
Thought I'd hit up a few challenges with the language I wrote a few days ago.  TIO doesn't yet have an interpreter for it (coming soon I hope). Character set and execution is similar to ><>, but with an extended set of available commands, multiple IPs, and IP "energy" (some commands--such as o (sort)--require/consume mana and IPs with 0 mana are terminated).
'ÿY'$@

Try it online!
Explanation
>          Implicit entry (single line programs only; does not occupy a cell)
 'ÿ        push ÿ as a character
   Y       multiply by 1000 (implicit conversion to 255)
    '$     push $ as a character
      @    print entire stack and terminate the IP

An earlier attempt was e|$$$':* (push 15, reflect, push 15, multiply, duplicate, push $, print, print, print, (print: empty stack: IP terminated), resulting in $196196 however I realized that I could use @ instead of $$ which got me f|@$':* with a score of $225225, but further experimentation showed that I could get down to six characters starting from Pbp'$@ (push PI, push 11, power, push $, print and terminate), which was c5p'$@. But that ran into the issue of no digit characters allowed (ironically, both entries resulted in higher outputs).
2 IPs (because the language can): $148642 (max $155100)
>e'$@
FFm\>

Try it Online
Explanation
This will be a little hard to follow, but hopefully it makes sense. Instruction pointers wrap when they reach the edge of the program.
>
    >      Entry points (each IP begins with 10 mana)
----------------------
 e         Push 14
F          Fizzle
----------------------
  '        Enable single character read mode
 F         Fizzle
----------------------
   $       Push '$'
  m        Push current mana (8)
----------------------
    @      Print stack ($14) and terminate
   /       Reflect upwards
----------------------
   $       Pop and print (8)

----------------------

   /       Reflect right
----------------------
   $
mFF/       Push current mana (6), fizzle twice, reflect up
           At this point the IP is in a loop. It will terminate
           when it pushes a (2) and fizzles twice to end up with 0 mana

If I'm reading the challenge correctly, 7 bytes only allows for a maximum of $232368

@recursive Program is only 6 bytes, the header is typo'd.

ÿ is a two byte character, so this is 7 bytes

C (clang), $70560 (34 bytes)
main(){printf("$%d",'*'*'*'*'(');}

Try it online!

Z80Golf, $123456 (12 bytes)
00000000: 0606 3e24 ffc6 0c3c ff10 fc76            ..>$...<...v

Try it online!
Assembly:

ld b, 6 ; loop 6 times
ld a, 24h ; '$' char
rst 38h
add 0Ch ; 30h='0' char
loop:
	inc a
	rst 38h ; putchar
	djnz loop
halt

Try it online!

Oracle SQL, 54 bytes ($50200)
select '$'||to_number(rawtohex('─↑'),'xxxx') from dual

Symbols must have codes 196 and 24 because 196 * 256 + 24 = 52000.
Symbols may differ for different code pages, demonstrated result tested for code page 437.
SQL> select '$'||to_number(rawtohex('─↑'),'xxxx') from dual
  2  /

'$'||TO_NUMBER(RAWTOHEX('─↑'),'XXXX')
-----------------------------------------
$50200

SQL> exit;
Disconnected from Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options

C:\Windows\System32>chcp
Active code page: 437

Oracle SQL, 44 bytes ($57343)
select '$'||ascii(unistr('\DFFF')) from dual

Max allowed number in this case is 58534 but the max one in HEX without digits is DFFF.
SQL> select '$'||ascii(unistr('\DFFF')) from dual
  2  /

'$'||A
------
$57343

Nice work. You should put the resulting salary in your header as well, so we can see that at a glance.

Canvas, $279936 (5 bytes)
$６７＾＋

Try it here!
Note that the ６ & ７ there are full-width characters, not ASCII numbers.

Ink, $56789, 43 bytes
$<>
-(o)~temp q=o+o+o+o
-(t){t+q}{t<=q:->t}

Try it online!
Explained
$<>               // Print a dollar sign and do not print a trailing newline.
-(o)              // Create a gather, and give it the label o. This creates a variable o, which keeps track of how many times this gather has been reached
                  // It is currently set to 1, and it will stay that way.
~temp q=o+o+o+o   // Create a variable q, containing the number 4.
-(t)              // Another label, another variable.
{t+q}             // print t + q, that is to say t + 4
{t<=q:->t}        // If t is not greater than q, jump to the gather labelled t
                  // (this automatically increments the t variable)

Alternative solution: $66666, 31 bytes, but
I did find a better solution, but I don't like it, because it abuses a bug in the interpreter:
-(n){|}$<>
-(t){t<n+n:{n+n}->t}

Try it online!
The {|} is a sequence - it outputs one string (the empty string, in this case) the first time the line is reached, and another string (which in this case is also the empty string) every subsequent time the line is reached.
This might not seem useful here, since we never return to that line. But in the current version of Inklecate, when a sequence occurs immediately after a labelled gather, the gather's readcount increments three times rather than the usual one.
This makes it easy to produce a 3, which we then use to print the number 6 five times.

Befunge-93 (FBBI), $209024 (8 bytes)
",**.@G$

Try it online!

Note that this beats the previous Befunge-93 answer because this interpreter doesn't follow spec on pushing a space when wrapping

Cascade, $177827, 10 bytes
^$
 #"

Try it online!
I'm lucky here in that  counts as a letter variable, which allows me to fetch its ordinal value, with the cost that it is a multi-byte character.

Go, $84426
func f(){print("$",'')}

The character in the single quotes is the Unicode character with code point U+149CA, encoded as 4 bytes in UTF-8. The Unicode standard does not currently assign it a value, but it is nevertheless valid to place it in Go source code, earning me only 18 cents below the maximum for 27 bytes. If you prefer, the character U+14646 Anatolian Hieroglyph A530 is the nearest that is assigned, though it only gets me $83526.

Wren, 34 bytes, $71021
Wren's verbosity ruined the game.
System.printAll(["$"]+"
".bytes)

Try it online!

Whitespace, $ 65,025 (37 bytes)
[S S S T    S S T   S S N
_Push_36_$][T   N
S S _Print_as_character][S S S T    T   T   T   T   T   T   T   N
_Push_255][S N
S _Duplicate_255][T S S N
_Multiply][T    N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Print '$' to STDOUT
Integer n = 255 * 255
Print n to STDOUT

I've created this 05AB1E program to generate this largest binary value that is still within the allowed salary based on the byte-count of the other necessary Whitespace commands, which resulted in 11111111 (255).

Deadfish~, $101111 (21 bytes)
iisiisc{{d}}iiisioioo

Try it online!

Knight, $126126 (13 bytes) $127127 (15 bytes)
O++"$"=d+A"~"Td

Try it online!
Output:
$127127

Now that ASCII is standard, this becomes very easy.
O++"$"=d+A"~"Td
         A"~"   # ASCII value of "~", 126
        +    T  # Add TRUE (coerced to 1) to get 127
      =d        # Assign 127 to d
  +"$"          # Prepend "$", this stringifies d
 +            d # Append 127 again to get "$127127"
O               # Output

$1001: +A"~"T

Squire, $77777 (27 bytes) $80000 (28 bytes)
proclaim("$"+arabic(M*LXXX))

Outputeth:
$80000

True Squire programmers needeth not the characters 0123456789, rather, they useth Roman numerals.
# Proclaim to ye standard output...
proclaim(
    # A dollar sign,
    "$"
    # and M*LXXX in thy strange Arabic numeral system,
    # what one might write as 80000
    + arabic(M*LXXX)
)

$2223: M*LXXX should've been obvious lol

Squire without Roman numerals (commit 93d3bf1), $55555 (38 bytes)
proclaim("$"+arabic(x=length(""+n))*x)

Sampersand doubteth my first solution, claiming that Roman numerals art "cheating". I contemplated catapulting him, but nay, I wouldns't want to slay the creator of this divine language.
Abuseth a blunder in commit 93d3bf1, where the program counteth "" + null as V characters long.
# Proclaimeth to ye standard output...
proclaim(
   # A dollar sign,
   "$"
   # appended to the Arabic numeral 5
   +arabic(
     # Since n naught exist, it evaluateth to "null".
     # Assigneth the length of this to "x"
     # blunder: "null" art IV characters, not V, you jest
     x = length("" + n)
   )
   # Multiplieth the string "5" V times to get "55555"
   * x
   # Reward: "$55555"
)

Rattle, $ 180180 (9 bytes)
$|bn*~/bb

Try it Online!
Explanation
$|          take "$" as a variable
  b         add "$" to print buffer
   n        get ASCII value of "$" (36)
    *~      multiply by 10 ("~" acts as a zero here)
      /     divide by 2
       bb   add to print buffer twice
            (implicit output of "$180180")

Thanks for your answer! Unfortunately the "0" character is not allowed in the source code...

@NicolaSap thanks for pointing that out! That slipped my mind when I posted my answer - I've updated it so the 0 is replaced with ~, which does the same thing in this case

Vyxal ṡ, 6 bytes, $260847
\$»⟑¬ǎ

Try it Online!

Zsh, $138166 (14 bytes)
<<<\$$[##]
Attempt This Online!
 is the Unicode character with codepoint 138166. This is the maximum integer score for 14 bytes.

Trilangle, $177827 (10 bytes)
"$o!@"

That CJK character is U+2B6A3, and 0x2b6a3 is 177827 in decimal.
Try it on the online interpreter!

Pyth, $192169 (9 bytes)
s+\$CM"À©

Try it online!

Julia 1.0, $101937 (23 21 bytes)
print(:$,Int(''))

Try it online!
To obtain the magic value, I rounded down the maximum score for a solution with this byte count, then converted it to a Char.
-2 bytes thanks to amelies: print :$ instead of '/$'

21 print(:$,Int(''))

GolfScript, 6 bytes, $255,255
"$\xFF").

Try it online!
The \xFF should be a literal 255-codepoint character, which is a fairly common technique in a lot of languages, however 255 specifically doesn't work. There are multiple different character sets with different characters for 255, and golfscript parses none of them correctly. In other words, pretend that \xFF is only one character long because it should be able to.

Unfortunately Golfscript (or at least this interpreter) interprets strings as a ruby literal, which enforces utf-8 encoding. However, there are other interpreters written in other langs that might do what you're looking for

@JoKing I figured it was something like that

Forth (gforth), 33 bytes, $69696
CHAR , CHAR $ DUP EMIT OVER * * .

Try it online!
As much as I prefer jonesforth, gforth doesn't need trailing whitespace for . to work properly, so it saves a byte.

plain TeX (using pdftex), $91126 (24 bytes)
\$\number`[\number`~\bye

Output is printed into a PDF.
Explanation: \number` prints the decimal place in the ASCII table of the following character.

brainfuck, 44 bytes, $57777
Omg, first time trying this thing.... I don't even know how I did it xD
+++++++++[>++++>+<<-]>.>[>++++++<-]>-.++....

Try it online!

Pip, $192,450 $202,020 (9 8 bytes)
O'$t+tMh

Try it online!
Explanation
          Preset variables used: t = 10, h = 100
O'$       Output a dollar sign with no trailing newline
   t+t    10 + 10
      Mh  for each digit in 100
          The result is the list [20;20;20]
          Output, concatenating items together (implicit)

PHP, 18 Bytes  $98301
Using the defined constants of php core.
$<?=E_ALL*SIGQUIT;

It's simple E_ALL = 32767 and SIGOUIT = 3
Output
$98301

**No restriction on use of defined constants :D

Gonna fix it (should not post from my phone)

Actually the ouytput is $98301

PHP, $122122 (17 bytes)
$<?=$a=ord(z),$a;

first attempt, $80662, 25 bytes:
$<?=(M_PI**M_PI)**M_PI<<!A;

test script

Swift 4, $50653 (50 bytes)
let a=UnicodeScalar("%")!.value;print("$\(a*a*a)")

Try it online!

Using your code you can golf this a bit (I have never done swift). Move the variable into the code itself and use a higher char for the unicode value and replace the aaa with a single call. https://tio.run/##Ky7PTCsx@f@/oCgzr0RDSSVGIzQvMzk/JTU4OTEnsUhD6f206UqainpliTmlqZpKmv//AwA

BASH, $82154 (28 bytes)
printf \\b!T|xxd -p|tr $[] $

Try it online.
This one requires an ASCII-capable machine, as \b, !, T must have code table positions 0x08, 0x21, 0x54 respectively. $[] is an empty arithmetic context whose result is 0.

Python 3, $78011 & 23 bytes
print("$",ord(""))
This is really simple, I just used the largest ordinal value I could find.
Try it online!

Backhand, $189642 (9 bytes)
""o@$*O}

Try it online!
This was a bit of a weird one. The unprintable in the middle has a char value of 24.
Explanation:
Note that the pointer typically moves three steps at a time
"            Starts a string literal
   @        Pushes some characters to the stack
             Bounces off the edge and go left
 "  $  O     Push some more chars and end the string literal
             Bounce off the edge and go right
  o          Output the $
     *       Multiply the O (79) by the unprintable (24) = 1896
        }    Step to the right, which bounces off the edge, so steps left instead
       O     Output the 1896
 "  $        Start another string literal and reflect
  o  *  }    Push chars and reflect
  o  *       Push more chars and reflect
 "           End string literal
    $  O     Swap the o and * and outputs the * as a number (42)
   @        Unprintable (ignored) and then terminates

Most of this was from accidentally using } (step right) instead of { (step left) as the last char, which led me to find out that this used the O (output number) twice, so I could avoid having to do too much more fiddling.

Lua, $74088 (32 bytes)
s='*'x=s:byte()print('$'..x*x*x)

Try it online!
How:
s:byte()returns an integer equivalent to string s ASCII value, '*' value is 42, 42^3=74088. I guess this is the optimal solution for the size of the code I managed to think of, feel free to prove me wrong.

Aheui (esotope), 30 bytes, $73636
밦밦따빠맣빠뱘휉망어

Try it online!

Explanation:
밦: push 6, move cursor right by 1(→).
밦: push 6, →
따: mul(push 36), →
빠: dup(push 36), →
맣: print as character(36 > '$'), →
빠: dup(push 36), →
뱘: push 7, move cursor right by 2(→→).
휉: end.
망: print as integer, →
어: move cursor left by 1(←).

Note: Print instruction moves cursor in reverse direction if current storage is empty.

C (gcc) - 26 bytes - $53159
main(){printf("$%d",'ϧ');}

Try it online!

Isn't the max for 26 bytes $86850.03? Couln't you use a higher unicode value?

This is actually 27 bytes.

C, $82154 (28 bytes)
main(){printf("$%x",'!T');}

Try it online!

cQuents, $177800 (10 bytes)
@$#t:tto۲

Try it online!
Explanation
@$          prepend $
  #t        output tenth term in sequence
    :       each term in the sequence equals
     tt       10 * 10 *
       o۲               python ord("۲"), which is 1778

Perl 6, 18 bytes ($114431)
say '$'~ord ''

33, $139,968 (12 bytes)
"$"jcaaaxxpo

Explanation
"$"       p  | Prints '$'
   jca       | Loads 36 (ASCII value of '$') into the accumulator and counter
      aaxx   | Trebles it (108), then multiplies the result by 1,296 (139,968)
           o | Prints it

BRASCA, $165100 (11 bytes) $192100 (9 bytes)
'$o'ÀHgn

Try it online!
Explanation
'$o          - Print $
   'À        - Push 192
     H       - Push 100
      gn     - Concatenate and print

Pxem, 9 bytes (filename only), $192255.

Filename (escaped unprintables): $.p\300\377.n.n

Try it online!

Ly, $151515 (9 bytes) (11 bytes) (12 bytes)
'/' -::'$ouu

Try it online!
'/' -::'$ouu  #
'/            # Push codepoint for "/" (47) on the stack
  '           # Push codepoint for " " (32) on the stack
   -          # Subtract yielding (15)
    ::        # Duplicate the top of the stack twice
      '$:o    # Push a "$" on the stack and print it as a char
          uu  # Print two entries on the stack as numbers (1515)

At the end of the code the stack contains 15 which is printed as a int by default, making the final concatenated output $151515.

Ah, I read the challenge wrong... I thought 4-9 chars was 353553.  I'll rework the code...

Fixed the code...

ha!  this challenge is going to make me insane. :)  OK, back into the code.

Rattle, 14 bytes, $122265
$|b<=@*~//*`*b

Try it online!
Try to outgolf this in Rattle!!!!!
Explanation
|                 takes anything to the left of it as input ("$")
 b                adds "$" to the print buffer
  <               moves the pointer left (wraps around to pointer = 99)
   =@             sets the value on top of the stack to the pointer ( = 99 )
     *~           multiplies this value by 10 ( = 990 )
       //         divides by two, twice ( = 247.5 )
         *`       multiplies this value by its rounded self ( = 247.5 * 247 = 61132.5)
           *      multiplies this value by 2 ( = 122265)
            b     adds this value to the print buffer, prints and clears buffer implicitly

Note that this works in the current version of Rattle, but the data tape may eventually be expanded past 100 slots (the TIO link here is permanent for the current Rattle version, 1.1.2)

Risky, $200000 (8 bytes)
\*\!/**+:}!_\*+

Try it online!
Explanation:
       +         ;  Join
   !             ;    Pair of
\*\              ;      "$" (6 * 6)
    /**          ;      "2" (5 * 10)
           _     ;    Fill
        :}!      ;      [1, 0, 2, 0, 1] (100 in base 3)
            \*+  ;      "0" (6 * 8)

Thunno KJ, $93,648.04 (7 bytes)
AwaA^'$

Attempt This Online!
Explanation
Aw       # Push pi
  aA     # Push 10
    ^    # Push pi ** 10
     '$ '# Push "$"
         # The flags concatenate them
         # (Because of the way Thunno's
         # stack works, the "$" gets
         # put in front of the number)
         # Implicit output

Excel,  $260847, (6 Bytes)
(Max of 260847.43 at 6 bytes)
=Row()
In cell A260847 (or any other cell in the row), simply have =Row(). Row returns the row of the reference in question, and when nothing is given, simply returns the row of the cell that the formula is in.
We can then use Excel's Accounting formatting to insert the $ for us (or any other type of custom formatting).
This makes us extremely efficient and effective!

Welcome to PPCG! While this is a clever idea, it is unfortunately not valid as you need to output the $ as well!

Giuseppe: Is having the $ displayed not valid?

Yep, the requirements are for a program/function that outputs a text containing a dollar sign ($, U+0024) and a decimal representation of a number (integer or real) -- I missed this my first time as well!

One could also argue that the six bytes in 260847 (the cell's position) have to be included, since it is information available to the program.

@JonathanFrech what’s the meta consensus on that? I could not fin an answe here

@JayCe Loopholes that may be applicable include this and this.

Clever, but I have similar questions. My major problem with using cell formatting to produce part of the required output is: how do you account for that in the score? Surely it should impact the score in some way, if only to add 1 (1 click on the currency format button). For that matter, should there be some adjustment to the score for requiring the user to scroll down to row 260,847? Do we could how many times you have to press page down? Or the keystrokes to jump to a certain cell?

@BradC I would intuitively argue that the cell's entropy which is being used is the information stored in its position. This information is in this case represented decimally using six bytes. I, however, also could not find definitive consensus on this specific byte count issue.

+6 bytes for column, +ton of bytes for dollar being displayed automatically


text:
How many cubes can be built
task
Your task is to build a structure with \$n\$ cubes. The volume of cubes follow the following sequence (bottom -> top)
\$n^3, (n-1)^3, (n-2)^3,...,1^3\$
input
The total volume of the structure (\$V\$).
output
value of (\$n\$), i.e : The total number of cubes.
\$V = n^3 + (n-1)^3 + .... + 1^3\$
notes

Input will always be an integer.
Sometimes it isn't possible to follow the sequence, i.e : \$V\$ doesn't represent a specific value for \$n\$. In that event return -1, or a falsy value of your choosing (consistency is required though).
This is code-golf so shortest answer in bytes for each language wins.
No answer will be marked accepted for the above mentioned reason.

requests

This is my first challenge on the site so bear with me, and forgive (and tell me about) any mistakes that I made.
Kindly provide a link so your code can be tested.
If you can, kindly write an explanation on how your code works, so others can understand and appreciate your work.

examples
input  : 4183059834009
output : 2022

input  : 2391239120391902
output : -1

input  : 40539911473216
output : 3568

Thanks to @Arnauld for the link to this :

Isn't that nice.
Link to orignial : Link

This is a nicely written first challenge. However, I'd strongly advise to add a few test cases.

@Arnauld, ok working on it right now and thanks :)

OEIS A000537

Can you please explain how input 4183059834009 gives output 2022?

What's the maximum input size we need to be able to handle?

@SuperJedi224 AFAIK the default rule is "whatever range the natural integer type of your language has", of course without using a small range for a loophole -- at least that's what I assumed in my answer :o

JavaScript (ES7), 31 bytes
A direct formula. Returns 0 if there's no solution.
v=>(r=(1+8*v**.5)**.5)%1?0:r>>1

Try it online!
How?
The sum \$S_n\$ of the first \$n\$ cubes is given by:
$$S_n = \left(\frac{n(n+1)}{2}\right)^2 = \left(\frac{n^2+n}{2}\right)^2$$
(This is A000537. This formula can easily be proved by induction. Here is a nice graphical representation of \$S_5\$.)
Reciprocally, if \$v\$ is the sum of the first \$x\$ cubes, the following equation admits a positive, integer solution:
$$\left(\frac{x^2+x}{2}\right)^2=v$$
Because \$(x^2+x)/2\$ is positive, this leads to:
$$x^2+x-2\sqrt{v}=0$$
Whose positive solution is given by:
$$\Delta=1+8\sqrt{v}\\
x=\frac{-1+\sqrt{\Delta}}{2}
$$
If \$r=\sqrt{\Delta}\$ is an integer, it is guaranteed to be an odd one, because \$\Delta\$ itself is odd. Therefore, the solution can be expressed as:
$$x=\left\lfloor\frac{r}{2}\right\rfloor$$
Commented
v =>                    // v = input
  ( r =                 //
    (1 + 8 * v ** .5)   // delta = 1 + 8.sqrt(v)
    ** .5               // r = sqrt(delta)
  ) % 1 ?               // if r is not an integer:
    0                   //   return 0
  :                     // else:
    r >> 1              //   return floor(r / 2)

Recursive version, 36 35 bytes
Returns NaN if there's no solution.
f=(v,k=1)=>v>0?1+f(v-k**3,k+1):0/!v

Try it online!
Commented
f = (v,                   // v = input
        k = 1) =>         // k = current value to cube
  v > 0 ?                 // if v is still positive:
    1 +                   //   add 1 to the final result
    f(                    //   do a recursive call with:
      v - k ** 3,         //     the current cube subtracted from v
      k + 1               //     the next value to cube
    )                     //   end of recursive call
  :                       // else:
    0 / !v                //   add either 0/1 = 0 if v is zero, or 0/0 = NaN if v is
                          //   non-zero (i.e. negative); NaN will propagate all the
                          //   way to the final output

Hi, I created an answer (to my own question) link, since you published first I wanted to ask is it ok to publish twice in same language ?

@Any3nymoususer Posting several answers in the same language is perfectly fine. Answering its own challenge should not be done before a couple of days, but I guess that's now OK.

Oh, in that case thnx for telling me :)

05AB1E, 6 bytes
ÝÝOnIk

Try it online!
Port of Jonathan's Jelly answer. Take the cumulative sum of [0 ... n], square each and find the index of V.

05AB1E, 7 bytes
ÝÝ3mOIk

Try it online!
How it works
ÝÝ3mOIk – Full program.
ÝÝ      – Yield [[0], [0, 1], [0, 1, 2], ... [0, 1, 2, ... V]].
  3mO   – Raise to the 3rd power.
     Ik – And find the index of the input therein. Outputs -1 if not found.

8-byte alternative: ÝÝÅΔ3mOQ.

I have no idea why both 3mO and nO work... Probably also mention -1 is the falsy value.

R, 42 40 bytes
-2 bytes thanks to Giuseppe
function(v,n=((1+8*v^.5)^.5-1)/2)n*!n%%1

Try it online!
Port of Arnauld's JavaScript answer. Also returns 0 if there's no solution.

Good catch @Giuseppe !

vote for R as language of the month!

@Giuseppe done!

Jelly,  5  4 bytes
RÄ²i

A monadic link, yields 0 if not possible.
Try it online! way too inefficient for the test cases! (O(V) space :p)
Here is an 8-byte version that performs a cube-root of V first to make it O(V^(1/3)) instead. Using that 8-byte version here is a test-suite
How?
$$\sum_{i=1}^{i=n}i^3=\left(\sum_{i=1}^{i=n}i\right)^2$$
RÄ²i - Link: integer, V
R    - range of v -> [1,2,3,...,V]
 Ä   - cumulative sums -> [1,3,6,...,(1+2+3+...+V)]
  ²  - square -> [1,9,36,...,(1+2+3++...+V)²] ( =[1³,1³+2³,1³+2³+3³,...,(1³+2³+3³+...+V³)] )
   i - first 1-based index of v? (0 if not found)

Is this valid ? since it can't handle input shown in test cases ? (I haven't got any idea)

It is valid, it's just the range that gives a memory error for those test cases. Try smaller values like 36

@FiveCrayFish973 yes, it's quite normal to sacrifice usability/efficiency/etc for byte-count in code-golf (unless the spec enforces some limits). See the 9-byte version for one that works for your test cases.

@JonathanAllan cool, I wasn't aware on what the rules of this community suggest. If it's valid, it's valid. Cheers

Too bad Ä²i behaves like ²⁼ (Ị, in other words).

Elixir, 53 bytes
&Enum.find_index 0..&1,fn n->&1*4==n*n*(n+1)*(n+1)end

Try it online!
Port of Jonathan's Jelly answer.

Elixir, 74 bytes
fn v->Enum.find_index 0..v,&v==Enum.sum Enum.map(0..&1,fn u->u*u*u end)end

Try it online!
Definitely sub-optimal. But I am just an Elixir newbie! :) Returns nil for "invalid" values of V.

Japt, 7 bytes
o³å+ bU

Try it

Explanation
            :Implicit input of integer U
o           :Range [0,U)
 ³          :Cube each
  å+        :Cumulatively reduce by addition
     bU     :0-based index of U

Alternative
Çõ³xÃbU

Try it

Cubix, 27 bytes (or volume 27?)
Seems like the right place for this language.
I@.1OW30pWpP<s)s;;q\.>s-.?/

Try it online!
This wraps onto a 3x3x3 cube as follows
      I @ .
      1 O W
      3 0 p
W p P < s ) s ; ; q \ .
> s - . ? / . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Watch it run
It essential brute forces by taking increasing cubes away from the input.  If it results in zero, output n otherwise if there is a negative result, print 0 and exit.

Perl 6, 30 29 26 bytes
-4 bytes thanks to Jo King
{first :k,.sqrt,[\+] ^1e4}

Try it online!
Brute-force solution for n < 10000. Uses the equation from Jonathan Allan's answer. 37 36 bytes solution for larger n (-1 byte thanks to Jo King):
{!.[*-1]&&$_-2}o{{$_,*-$++³...1>*}}

Try it online!
Returns False if there's no solution.
Explanation
               o  # Combination of two anonymous Blocks
                {                 }  # 1st Block
                 {               }   # Reset anonymous state variable $
                  $_,*-$++³...1>*    # Sequence n,n,n-1³,n-1³-2³,... while positive
{             }  # 2nd Block
 !.[*-1]&&       # Return False if last element is non-zero
          $_-2   # Return length of sequence minus two otherwise

For the brute force, you could do 0..$_ to be valid for all numbers, even if it will time out on larger ones. For normal golfing, you can remove the . from the first one and change the second from 0>=* to 1>*

26 bytes

JavaScript (Node.js), 28 bytes
a=>a**.5%1?0:(2*a**.5)**.5|0

Try it online!
I know it's my own question and all, but I had a better answer (for this lang) then is present, so I posted. Hope it's ok

Matlab, 27 bytes
@(v)find(cumsum(1:v).^2==v)

Returns the n if exists or an empty matrix if not.
How it works
            1:v            % Creates a 1xV matrix with values [1..V]
     cumsum(   )           % Cumulative sum
                .^2        % Power of 2 for each matrix element
                   ==v     % Returns a 1xV matrix with ones where equal to V
find(                 )    % Returns a base-1 index of the first non-zero element

Try it Online!
Note It fails for large v due to memory limitations.

APL (Dyalog), 18 bytes
{o×⍵≥o←⍵⍳⍨+\3*⍨⍳⍵}

Try it online!

Python 3, 60 bytes
lambda V:[*[(n*-~n/2)**2for n in range(V+1)],V].index(V)%-~V

Try it online!
-6 thanks to Mr. Xcoder.
If we can throw an error in case there's no \$n\$ for a particular \$V\$, we can get this down to 51 bytes:
lambda V:[(n*-~n/2)**2for n in range(V+1)].index(V)

Try it online!

Python 3, 53 48 bytes
f=lambda V,n=1:V>0and f(V-n**3,n+1)or(not V)*n-1

Try it online!
-3 bytes from Jo King
Returns -1 for no answer.
Only works up to n=997 with the default recursion limits.
Repeatedly takes bigger and bigger cubes from the volume until it arrives at zero (success, return number of cubes removed), or a negative number (no answer).
Explanation:
f=lambda V,n=1: # f is a recursive lambda taking the volume and the cube size (defaulting to 1)

               V>0and               # if the volume is positive
                      f(V-n**3,n+1) # then we are not to the right cube size yet, try again with n+1, removing the volume of the nth cube

                                   or # if V is not positive
                                     (not V)*n-1
                         # case V == 0:
                         # (not V)*n == n; return n-1, the number of cubes
                         # case V < 0:
                         # (not V)*n == 0; return -1, no answer

and/or or lists are usually shorter than if/else. 50 bytes

@JoKing Thanks! I got two more bytes off also.

not V => V==0 or V>-1

Perl 6, 33 bytes
{$!+>1 if ($!=sqrt 1+8*.sqrt)%%1}

Try it online!
This uses Arnauld's method. Returns an Empty object if the number is not valid.

dc, 19 bytes
4*dvvdddk*+d*-0r^K*

Input and output is from the stack, returns 0 if no solution.
Try it online!
Explanation
If there's a solution n, the input is ((n^2+n)^2)/4. So we'll calculate a trial solution as n=sqrt(sqrt(4*input)), using dc's default 0 decimal place precision for square roots, then compare (n^2+n)^2 to 4*input to see if it's actually a solution.
4*dvv         Calculate a trial solution n (making a copy of 4*input for later use)
dddk          Store the trial solution in the precision and make a couple copies of it
*+d*          Calculate (n^2+n)^2
-             Subtract from our saved copy of 4*input - now we have 0 iff n is a solution
0r^           Raise 0 to that power - we now have 1 if n is a solution, 0 if not
K*            Multiply by our saved trial solution

The penultimate line relies on the non-obvious fact that to dc, 0^x=0 for all nonzero x (even negative x!) but 0^0=1.

gvm (commit 2612106) bytecode, 70 59 bytes
(-11 bytes by multiplying in a loop instead of writing the code for multiplying twice)
Hexdump:
> hexdump -C cubes.bin
00000000  e1 0a 00 10 00 1a 03 d3  8a 00 f6 2a fe 25 c8 d3  |...........*.%..|
00000010  20 02 2a 04 0a 01 1a 02  00 00 20 08 4a 01 fc 03  | .*....... .J...|
00000020  d1 6a 02 52 02 cb f8 f4  82 04 f4 e8 d1 6a 03 0a  |.j.R.........j..|
00000030  03 fc d5 a8 ff c0 1a 00  a2 00 c0                 |...........|
0000003b

Test runs:
> echo 0 | ./gvm cubes.bin
0
> echo 1 | ./gvm cubes.bin
1
> echo 2 | ./gvm cubes.bin
-1
> echo 8 | ./gvm cubes.bin
-1
> echo 9 | ./gvm cubes.bin
2
> echo 224 | ./gvm cubes.bin
-1
> echo 225 | ./gvm cubes.bin
5

Not really a low score, just using this nice question for testing gvm here ;) The commit is older than the question of course. Note this is an 8bit virtual machine, so using some code handling only the natural unsigned number range 0-255, the test cases given in the question won't work.
Manually assembled from this:
0100  e1         rud                     ; read unsigned decimal
0101  0a 00      sta     $00             ; store to $00 (target sum to reach)
0103  10 00      ldx     #$00            ; start searching with n = #0
0105  1a 03      stx     $03             ; store to $03 (current cube sum)
0107  d3         txa                     ; X to A
                   loop:
0108  8a 00      cmp     $00             ; compare with target sum
010a  f6 2a      beq     result          ; equal -> print result
010c  fe 25      bcs     error           ; larger -> no solution, print -1
010e  c8         inx                     ; increment n
010f  d3         txa                     ; as first factor for power
0110  20 02      ldy     #$02            ; multiply #02 times for ...
0112  2a 04      sty     $04             ; ... power (count in $04)
                   ploop:
0114  0a 01      sta     $01             ; store first factor to $01 ...
0116  1a 02      stx     $02             ; ... and second to $02 for multiplying
0118  00 00      lda     #$00            ; init product to #0
011a  20 08      ldy     #$08            ; loop over 8 bits
                   mloop1:
011c  4a 01      lsr     $01             ; shift right first factor
011e  fc 03      bcc     noadd1          ; shifted bit 0 -> skip adding
0120  d1         clc                     ;
0121  6a 02      adc     $02             ; add second factor to product
                   noadd1:
0123  52 02      asl     $02             ; shift left second factor
0125  cb         dey                     ; next bit
0126  f8 f4      bpl     mloop1          ; more bits -> repeat
0128  82 04      dec     $04             ; dec "multiply counter" for power
012a  f4 e8      bne     ploop           ; not 0 yet -> multiply again
012c  d1         clc
012d  6a 03      adc     $03             ; add power to ...
012f  0a 03      sta     $03             ; ... current cube sum
0131  fc d5      bcc     loop            ; repeat unless adding overflowed
                   error:
0133  a8 ff      wsd     #$ff            ; write signed #$ff (-1)
0135  c0         hlt                     ;
                   result:
0136  1a 00      stx     $00             ; store current n to $00
0138  a2 00      wud     $00             ; write $00 as unsigned decimal
013a  c0         hlt

edit: I just fixed a bug in gvm; without this fix, gvm tried to read binary programs in text mode, which might break (code above doesn't contain any 0xd bytes so won't break on windows without this fix).

K (oK), 21 bytes
{(,_r%2)@1!r:%1+8*%x}

Try it online!
Port of Arnauld's JS answer.
How:
{(,_r%2)@1!r:%1+8*%x} # Main function, argument x
             %1+8*%x  # sqrt(1+(8*(sqrt(x)))
           r:         # Assign to r
         1!           # r modulo 1
        @             # index the list:
 (,_r%2)              # enlist (,) the floor (_) of r modulo 2.

the function will return (_r%2) iff 1!r == 0, else it returns null (0N). That is due to the single element in the list having index 0, and trying to index that list with any number other than 0 will return null.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes