[Question]
      [
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="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});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[^>]+>|<\/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}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Score</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td><td>Size</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SCORE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
---
Edit: (rounded) maximum allowed score per byte count, for a quicker reference - [text here](https://tio.run/##HcFBCoAgEADAryySsIqKi0jRob8EZe1FQ7z0@g2aed5xt5pESuvAwBX6Xq8TyVEmsz6d60Cl0wHebzBpWgLFojSyo/izbC36GOZsjBH5AA):
[![enter image description here](https://i.stack.imgur.com/HpQNN.png)](https://i.stack.imgur.com/HpQNN.png)

[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 6 bytes, $255,255
```
"$\xFF").
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X0klpsLNTUlT7/9/AA "GolfScript ‚Äì 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.
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 33 bytes, $69696
```
CHAR , CHAR $ DUP EMIT OVER * * .
```
[Try it online!](https://tio.run/##S8svKsnQTU8DUf//O3s4BinoKIApFQWX0AAFV1/PEAX/MNcgBS0g1Pv/HwA "Forth (gforth) ‚Äì Try It Online")
As much as I prefer jonesforth, gforth doesn't need trailing whitespace for . to work properly, so it saves a byte.
[Answer]
## 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
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 44 bytes, $57777
Omg, first time trying this thing.... I don't even know how I did it xD
```
+++++++++[>++++>+<<-]>.>[>++++++<-]>-.++....
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwai7UCknbaNjW6snZ4dhKutDeLp6mlr6wHB//8A "brainfuck ‚Äì Try It Online")
[Answer]
# 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.
[Answer]
# PHP, $122122 (17 bytes)
```
$<?=$a=ord(z),$a;
```
---
first attempt, $80662, 25 bytes:
```
$<?=(M_PI**M_PI)**M_PI<<!A;
```
---
[test script](http://sandbox.onlinephpfunctions.com/code/8df083eef03171224badae57b02e404c443efebd)
[Answer]
# [Swift 4](https://developer.apple.com/swift/), $50653 (50 bytes)
```
let a=UnicodeScalar("%")!.value;print("$\(a*a*a)")
```
[Try it online!](https://tio.run/##Ky7PTCsx@f8/J7VEIdE2NC8zOT8lNTg5MSexSENJVUlTUa8sMac01bqgKDOvRENJJUYjUQsINZU0//8HAA "Swift 4 ‚Äì Try It Online")
[Answer]
# BASH, $82154 (28 bytes)
```
printf \\b!T|xxd -p|tr $[] $
```
[Try it online](https://tio.run/##S0oszvj/v6AoM68kTSEmJkkxpKaiIkVBt6CmpEhBJTpWQeX/fwA).
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`.
[Answer]
## Python 3, $78011 & 23 bytes
`print("$",ord("ìÇª"))`
This is really simple, I just used the largest ordinal value I could find.
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQ0lFSSe/KEVD6cPkpt1Kmpr//wMA)
[Answer]
# [Backhand](https://github.com/GuyJoKing/Backhand), $189642 (9 bytes)
```
""o@$*O}
```
[Try it online!](https://tio.run/##S0pMzs5IzEv5/19JKd9BRUvCv/b/fwA "Backhand ‚Äì 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.
[Answer]
# [Lua](https://www.lua.org), $74088 (32 bytes)
```
s='*'x=s:byte()print('$'..x*x*x)
```
[Try it online!](https://tio.run/##yylN/P@/2FZdS73CttgqqbIkVUOzoCgzr0RDXUVdT69CCwg1//8HAA "Lua ‚Äì 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.
[Answer]
# [Aheui (esotope)](https://github.com/aheui/pyaheui), 30 bytes, $73636
```
Î∞¶Î∞¶Îî∞Îπ†Îß£Îπ†Î±òÌúâÎßùÏñ¥
```
[Try it online!](https://tio.run/##S8xILc38///1hmUgNGXD650LXi9fDCI3zng7p/P18rlvpm35/x8A "Aheui (esotope) ‚Äì 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.
[Answer]
**C (gcc) - 26 bytes - $53159**
```
main(){printf("$%d",'œß');}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oCgzryRNQ0lFNUVJR/38cnVN69r//wE)
[Answer]
# C, $82154 (28 bytes)
```
main(){printf("$%x",'!T');}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oCgzryRNQ0lFtUJJR51DMURd07r2/38A)
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), $177800 (10 bytes)
```
@$#t:tto€≤
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/30FFucSqpCT/9qb//wE "cQuents ‚Äì 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
```
[Answer]
## Perl 6, 18 bytes ($114431)
```
say '$'~ord 'õªø'
```
[Answer]
# [33](https://github.com/TheOnlyMrCat/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
```
[Answer]
# BRASCA, ~~$165100 (11 bytes)~~ $192100 (9 bytes)
```
'$o'√ÄHgn
```
[Try it online!](https://tio.run/##zVt7c9s2Ev9fnwK120qqJVl2kibxWW7jJE3cNnHGdud643EVSIQkpiTBkFBk9TX33e6D5XbBhwgSFMHYjq2ZxBIJ7P72idfCX4oZ9@498oOPtuvzQJBwGXaIS8WsQ2zBAsG5EzYmAXeJsF1GklYOY370OKCeBX/iF/gL/k1ZI34gAjpmIzr@vdEYOzQMyWFAwzF9it/3GgQ@GxsbpwIadEjApnYITEMCVMgHGth05LAQGsiGFpuQ4dD2bDEctkLmTNp7DfkCP5uShuyYkklfYuNeKBsMyPmF@pzCs776aKQ8WvF4EjCyYMCAWrY3JewDC0CB@JWGZDyjICvy/S7POIAmQ5dbDOj@QJ2QZXC/sX1mdW2PWFTQ9LE9IR6X1oDuwKxnh1SIZau9lzbJ0IcGQ@wO5Fc9EGWrfb631925UDpNeECGHTIkwJR5c5cFVLBWjlSOkYYZ2iucOwKZqm/OkWWn8DSPQ7VMj/o@86wWD6xWRLjdTpsz0FmV5OAlK62@pOhEsXFGjHnEByMIZpElEzn7UAdVtRwmLYo2OpvZIVnYjkNCwcEHKHwTM0ZGYPDfmSA@D21hcy/ncYuZ7bChw7kfAtE//1YoMjJGh0CHRVI@R@aBSgBbDOM3RS8dRw6VlVs@h8hz7DFECdg2FUbfQnBfFXfzzTycEeg4Ao6CS2jSPGkE@tBgGDWQPtPB1hlvKVoU32epf6DOnBE@WUUMctJwwfcxD/y6lgm6jWzULhdkxIWAVAWc14o1jNpVSWd7IeTHVj9qUi2gEQLsofIvl3wFoCg82FVm5xwL7ieJM59oUrJqmAVMzAMv43nFSIybZIAhmyh2c2gqVcD9rPCfAWY/0dgphDECSgaPFFPIxDB5GJsk@aniS56SAcQk3dCkK5qkypWCIqz53iNd71Gxd8bnstibYeyC2gDGZHddEikhGMnY1svdrytukfSorVdKPzbhCY7HIdOKLN/knSrDJ2nRTmlJb0FSDvOmYqZ32Ohdnm7savCytWKRCc25AwOupCZHCIIjBHFAH6SVHzfaKavR3Has6GGen2Cur05s8MkQ5h3KnEN9CQOjw97PuWCKdXBykAxnkHy46@IIVZwp4OCTmyOAWQukD0i/OJEotOoOyI7SSvpIEeegnFpO1jywRBB0t/ONaNRV@sUd9eQTN0wU0y6CzTK4qMUAvCPASZRkpGaGstnEuexzAZ0SRNVdkpbYS3ZfL0Nzo1LTZ8GcVdt2QHbXc3pb2xzZZgUQpvSxYzX52JsauAY5XULGcgkNphAJnoDliy@XTzgNhCVNz1@SCdmfgMo96rKD4tsx2cewOWg0zjjEEy5uILRH82mHzCFvTaztMYYacKEW5pvJ9riHTUOHL4jFFx7hc@HPRdw83B6HEpiN6yLkORxKiYdDl8K8eBibMAIAhsgsvWIni7GlM8mNj80vefN//3059T7Ga7Moa5FDTD9RPsRs5VI/SyCbnJJER14BCNla/o5SXYZhOrHdl5ky8yab2oKlaqTUsllS5xqyF/kUELdRVmOlblZ4sEnkMLsPWfBAna6uyTR9TRBltJadSveLUV/w5B1zcjsG5HbNye0akLtnTu6eAbn75uTuG5B7YE7ugQG5b83JfWtA7qE5uYcG5B6Zk3tkQO6xObnHBuScGm5sEhY/16Bn4nmsRlyYGPd5jcAwCTSrRmSYmPdZDV82iY1ZDXcx8eaXdfzFxGF@qkXQhOKfG3tk8xkbBwxnBqbEk0c45@uaZOy/kc2RdwU2WyZsAmQjh7sTuZWr40NXI7B@zirBmDTCFYeNKwy5b9wadQgFlHoLlUhotxvFAVsKEI32MFOa0aBS8Obb5lrHUDdytdNfo3l0Xgq5z1UxndnauWivI6TMqLZwPVXUyCuK61gfV3E8sztein0L/eCJZd2wA@hcdosa@GkX8Z3OR3jGIG4BZNcE5DcI8tXcEbbvLG8B5DcmILejxCLYFLzHsj/YoW5NefNgt7dN0H4lVcqtucNvAeNXJhB/Q4jPL33ulSXqG7a6kdlDGUDvg6sgLDLH08PeBBZ@8dcQGLRou61L0oe2WNiwmK2Rlf5B0K@Pz64V8z8m6vpa5sPXz27Bnl@b4PsL8R2f3AK8v0zgDRHer7eC7zfAp/G@U@0ivgCcInBf7rLz1c71k7VTheypARAwUM9Iy@XQnMvIhMsTySU5kDETRj0xMJPmUM/nsAYfI3k6yCfevS/ZlFE4JNv8lYT3kLA1x4NSuVsPovDJGg6fmnnoVVoWUP9LRb06bDMFnpy/maJK2tNr6FCQxkVpXP5BVT/GR0REyzI6@vokYyTYJAkDfK9SfDlFy5O3eOOzGl9dnRvj8yv0RzxZ1RPq/cLlc0@YruC81Qqu34m6rlnDGdvoeuz0psJOd0gP633hiv7wnUyWUcFWXBrR7@7sPjT1u7S6qwXrzPy@QtsAwBfpGLc6Va1M2pq9jPjc1YTll8gyXFBfGlosONa1uSHh3pWT@Y1n/JGBfCfSplwkg5SYBYx9XhnHN66I8VVUpj3PKejxFPU45h6Om16qTHCXiHD4@f0EYywUKNIW/qFGETbNi1HuAHHZALJpNnvvuO1Jdl57lcjSjS8sYChPemNMc5BMMqkvc6QX967e0aujHARvoI4XWnXIA@EQJkn6he/m253e7r3e/QdvSbNHbPKCDA7IDtm9R@4/0HawgK9rYmXgiYUaWOvRWkZ6vuyQJSourbbtTQM@90dLRX0d4lB3ZFHyxx75AyWTLNtJXdTlxa3ZRsqA1EG2cjIlvhbrQCrgsl1rzDN0ADt2AJj3CwJEbBvH/Hjwa3V1BySK5jrxGK1UwCjKKxcaoESdDwbk/qO4qBl/7w/Ig4fl/ZQtZ2BxLpFg4YbsDqCr5T7Kyr0qg4w00Nr6bHL3VbEff7LUALlRLfalXP/YQCSwqtdsa527QPvXLG2TlZXJrK7AZY5cfvG6p1qSnuk8VNZsRem83lEKRKhlMtD8EuOcluLMBvple5UoFC9qVLmBWth23WJqNoWOto8NHI3LvTZZjoPF/09Onx4dxUWuVV63qkUpVJ6X1qPkRCmWrGtPo/Ajm7TGM/UcsN2BsLYGzaaBpY9LRTUJgtuXNg2@OkJ7qtBxBr27Bs4at4aYr8vFvKvG1Rh2JbAmnp9yTwTcIT84fFGtkH1UyM8sDGEhRW/6CAzVt09rJa4dPSVmouq69WYHqIsXYB55g@HzqOPg7qpjIM/03s/BrT@DIgaDO6uJ5n@aoIlDJhaMeXdhbwH1hbPLMf53dx3oe3SgMxa4Ni5FG9eTFPHCH7u0hcncchMBQD60ZCU4dci7uetXJHapddRrv1IfxRqUSkTvENGPgAJncwuYWId1ilzUAqpqbj@m3PBGaj12XZXdlgG7c2T3b6x77sqi6WLZfVHd0Zz3C5z0rl1gKSul7s5FhYXKpEqFyl4VqKym1kp7kZMWhuSbkvXgRkU18aSn68u6clcwzUrFzgxpRpc2Jc2GunKJrihJKfyAyV2fML2tjDdi43q44oUJfXG8/o7E5hnebrIFTA0nZDFjHizxOTAOZFQJG2wKbCewercqCuTrFdypt5hSNMfIWhaRyIMFzZ5eeTIvVOHF4HKlKpuv5Blacmc3f1fXKAWyyzHzBfmJLUccEg8WWwXB3Be5q2/FbB53fC7/QNpGQ@bE2TzlLovuOi@YJ8gi4N60g0cBfAHGIcCJq3CjqfTG85OT45M9ouueO3yPOqS3@XuQrl0qhgAufwqTESG6CHIUO258e6VRd@GwaquEAPiYZoWx9qD/CvuhdLB2FqLBiKGvx1hcrNKqNVsJcX2ArmjTIlktuVifRXJrxK4tcrW49UUtFRM/H/8P)
## Explanation
```
'$o          - Print $
   '√Ä        - Push 192
     H       - Push 100
      gn     - Concatenate and print
```
[Answer]
# [Pxem](https://esolangs.org/wiki/Pxem), 9 bytes (filename only), $192255.
* Filename (escaped unprintables): `$.p\300\377.n.n`
[Try it online!](https://tio.run/##jVh7V9rKFv@/n2JII5kxCckgKBKjUvBazlGq1rqsgK5AgoIhcJKgaOB89d49kyAQeruua2lmfvs5@zEPn4OnX58/l5x9q7vXdTr5Xn6nZO/pu7vdoq3vFnsdq6fber5Q1ItFWvwUOCFSnYkxGVrBM9L1fN5wpuORH6Kz6kPl7MysGjh8Gzvo0Qm7I6@XzfJZdzQcWp5NDjXbedG8ieui/GGWZrOJ8EXl@qspiDjhQ@p4oYCTiBixj1yexwN1LizM/mjUbx@@X9fMvK7vLMCLb9/rt2c/H6rfrq5OqtcmNZpIEKMvle9fH25Orr7XvzXK8ttcQCZ6Q@1slq9qhMajoD@NZ/KXWOTuf0g4w4lrhQ4Knjj/aBzC8HXk28HY7YfZrOX2rQCpj0gSIyoL4rEwl0yJfaVstvHj7Kx6XjPL3AZm9mwjeOr3QoOPEeNLAKf7NELiZ8IsU2Y5A4byI9c@zELoXywXCRnUs9zAEWazVRpXzaWns8CxkRRoU@1NMwL4865JXOE7ajMhzgU8C9EuJngESah4SH0JJ3QW@kitBqjV1NX9NpKaLW@7Lc0efWeMcrFy7b6wK2pRuWKIHaNhaC2Pzy/A3H0u1/I0zehUjHk8bd4zPZTmRW2sGeEqWNI3MUqpqI1S4N7@JkYpSHtpxtImRvWiqPXTjDub2D7wPaQxsNxNYbt7mxilIByk17eziVEKLr6kGXc3MapDxHppt/VNjOoQMSft4/4mRmlB1Py06fwmRilIv6YZ9zYxmgd/pmnG0iZG8@DjW5pxfxOjefDnPZ0E/TcYuGOlF13cxCiF2IZpy4VNjOrgzjAd771NjOrgjp02XdrECpB@OY2Bi2oK2wG@TBoDr8U0Bs5sMWwuzXDXSrYLmyRNyftVi05ZU04NG/rvlEm3cK5FWrjlsb@57RYRtdZOK9@iGnAFWm4bunW63t9l1xAzkdZ8nb69W3Zby0QNo@OCwrnxBs2uIc3QmvcJlZW4qCFbW9OhekhKzDfvj5U22AUPcDMeggv5Y8RceEp4YhzltoHEPYutw3rG3E1RUxjaARcgxRHMMlEAo4o2NjqXgMZsyjEo@GC0PxhtrbZgXGNbUJI4lH1DjGJzx4iphi2Oc6PKAgkrPLRipgGUltdE6nt722baQn8FgSXx@LTjxWqcZAHbmOc0XpwVS83B2/Llh8oc9y28TO25STy@QmRqFYjLNEkuj@wybnF8ThNN/Dd2JfYkyfrvBCW0ODpWEqL1e9i1Oo5rmkKLCiTiK8HN8cjrP3SDl57jh0M5I26pbcbdopgY2mPMw@qxFVGlNWekC9yiCc1adSmYdLDAEiIoTPoIxkJZOBYUbpbME4Pr/H9irolax3esZz6BvFWw4I5GY@SNQjS0wu5T33sUgFVaLFfGROtgSrhvKp@oySzDZ3o8EWHyz2KyxSeMDZqRN6LUG/lJrMAjwyCRZHx0qTSXCPn1n0bl/MSUxNy4taPrrZ29vZyX86RP1W@N65PGtSlJn/DY73thD85zziwmJGH22kVql8CJ/Svwu6b05eS03oggO3LgODYJfLhJYT6c9yZeN@yPPHSBayT63nxW/sakbdYMGLZleUk/wSTynXDieygjA8@S8teSAvghXVL@XlKYuiXheo3ATKp0hXyLr0h0ZQIXd0NVjYT5askzwVUS8fWj6hI9xVfK3YduuCm6fc851I9EvayuOPY1NiBSg1fIPS8/GQpFEMgahGJo0/wPZn7imSu2K/h84dH5TIBsQvzZbbQfohXTY1j661PfdXAGQkpGq5GESQTgbDbBt0BbEjxcV26UmuISlkUuGN2YwGO4put4j@ETviEGq6k6XGnrB6ZrkAnGNRPWEoQ@vlHqsqxQQv4V@LqEo5pcKJULRTJfGumD9Qt8umb4AZ8rVeVO@Umic1PIPZRRAzrDQrbT7Q/higmLdR4dH77jSSgYVRPEjTvwgfnCyhrcLewdVLPZ6kGxRHivGYBV/xXuC82dYluEbeLOLBTUaiIctyOw4FIsRgsQkKpp7uRJFLPA7T/sexNnziLOWKsHhRLwHBb3CINi40uzsWby08Q/CaqqhZLBsmdc4Lvtnytr7S6if4Gv14IQLAi3q8l6gZwMlBsS1U2dWxyYvI4h/ANWtspAVdvmDUsUm9XbHIQ8tPl80F4Jvb80DRHFvD/JNquBFYOvy6bZ9GaKLxVuKwPtyCKcgdklL5Eb8/KA8SayN0uhtz8KHf5e6P3DDSbF3VDXXAkXi3mC3jXXSEMgPUOxIHgcXWBGXyF2sAUBjUv8L1bhF9g6AnHZYpEo3yYRMZY7xrZJ1fw2tg50ss1yBt@VoP6T1jdIOuY2WSwebLsEKgbMCLktOBtyUI1CGd05PlyV@i/9ANQIrFBYUqyjwaF7NNhyy@7WoMzHGh9DjubxDguemXobygHec6m9WZh1iSAtnetBJNa4PvbuzffVH55XZnwuxZcBuGvBOcWeuarvPdNZdwIjW0ISUnv5xQEGd5cLnCXsnbfijsOLOT4YIyhcXtDPsmzI8uAAs02YFS2EPA7/IJnCgBi/XwZbru24DjyFIc/QCsn2BA0iy/UDEJdp3BL8pKlzjTKFPok3fTmet@eSwU4q9j8AuC11Ef8/wYR1yGjIXr0A@hvgMoZ2AamNwhrDbIbH8AKvwLO@bytO2B86yrg7nigvwbthw9udrOag8Oc3Lgqtvgs32MJKgNktOiqxmwy/L0kz6/UZdCHLVPO0sFco7ewWSkiKLNkU9flJo5acGhac@8Kn/zv/idYkOuwjQALgwBc4SRJ1uIbBj4CCOD1Y2BoJiqgTaTa1/EeIQX2KksxNP6Ff/wU "ksh ‚Äì Try It Online")
[Answer]
# Ly, $151515 ~~(9 bytes)~~ ~~(11 bytes)~~ (12 bytes)
```
'/' -::'$ouu
```
[Try it online!](https://tio.run/##y6n8/19dX11B18pKXSW/tPT/fwA "Ly ‚Äì 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`.
[Answer]
# [Rattle](https://github.com/DRH001/Rattle), 14 bytes, $122265
```
$|b<=@*~//*`*b
```
[Try it online!](https://tio.run/##7T1rd9vGsd/5K9ZgExESSZFymtRMFNt17HN9Thv7JG77QaZjkFiSqEGAwcOS7vX1X09n9gHsCwBpyU3qRieRxd3Z18zs7Mzs7HB3XWzS5O4v/bc0y6M0IdPxdHzWg5@QrsguyHI6WKYh9Wc9Aj/s1zpOF0FMtkGUqJ9XZbIsoItcLczojgaFWpKWxa4sHhaPk1AtLtLds9WPRbB8o5bmRZoFa6oW7dIoKWimFsVpunuUllVxXymHLjNt/GWZZTQpHqXbbZCET5OQXpl9GVNbctDcBPtLlBcuuEfp7tpcBA0fZlmgF9NlmkDxWi0MsvWTONCKdhks@M/laqUvWkCedZLANf0OJORvot2LVC2hSfhEdG7OL0pkjWsqYggLV/YEnjjqXT2raNba7CK6pLk@tSL9C1AKkJzX/KuWknNyMa@rjGGhdjRVK7T51m0di8XKi/nwxv/NSb/YRDmB/4oNJXG0jQqySjOSpGOSrshKEFvDCgzehH@BAWWFT4I4p3WdQWkbgDOHG3EqfgBiwrdjtQ/1IrFlq0Kxs6vPYvPjSJM5OSbTCS@vRUUFKrdjPStl0ymFcstB0fdpwhclNpK2ULm5tEJlIxqrZ78UwQbVL7KSWoSRw3IchGlyVJANVMaU0CxLs1xQ9tLomv06OjoSxINh3qH0/VoSeVr9dTZmP/Lj91@TC2CbhARhiIsqt0CknGxoRsnlJlpuoJAKXAFeSQCYXNZyl1xGxQYE/RVyGqCfvA3ikuZz8s1oRL5/9oLsynzDW@ZIjyFgGM6MoICyxTUZ8vmuyDvJvqsoAyItNwCzBFIP@WJYbfAGpllssrRcb3jxwB@TpytsB3MEkIB477whYeu53MAgcGYhemlOFhQQB0CsK2NSY/IMu7iMcjoE3PK@lb2wcs0MoNgBx8dNyu0CZ8uGRmhWtaVwdoaAoziGCYijDgeGuQFEck2KCCc3iMaUTFkTBpuV0MlltKQ@GX1L8h1dRijWApzfBIt4TzlgHOkWISHxhOSdIYdMp@JTkRZB7Os8wpkLD21gN/xnDP3FwZIOPOINPY@Dc2EpIfJdHBUD72uoZLVssucCCHafwYrRagCkkDgSukFVKyCwSnb8zvNxD5@fExi/Brd2s6C7AlD9SWEbtrS0R9Ngqw9iZSb4dG5iqf78MqnRpqzNuRomIwb1zHytNqNFmSU2tpCmyHqI0bqt3jOMykBg1KOXL4@McS181B@Uhbz0hhLFw6lvddCz8awLtVoWmqjsRB7nK/FPQbe7KZOh/aAs0hHTM7mE4AIhyNkOxw2db9IyBnFCq5ZnqvQusut6tk0YEIT@XCEiopzGdNuGcq3vig@v6HLgBTCAR05AwmQD7Ma3sSmnyiRqPvAvvMDTmZJeLemumDW2xI57ZsV0HOx2cEgPGJTfsHYEdO7KmCYqeyI7Tdt2ZP1Bbilz1haWbAwpA/rNQ7kR5ULSLshzyVCq/pXXMms6m81FJVA6QjJnQbKmDAEVvK8svSq8iOaKAoUfLQmqo1bDABfeTJYVTE4A3nzXnuFTVEgjW4JSY1Ck6nM6sccRf5yQqZM8dVt90lIvgZo1LRQ1kU16yJv5FrhQY1xNxFC@Pk7fFIlDwqErBMuGw2oQ3zhv@nhkykqu4YyVWiY@eS3SWQLOSD@/DHbsM6g9cDLHUQJiJg6kochaa9TrM5SVUm0eiL7qNfVN/PYrhqxK2tpzlszSLTvBSbTdpaAX72i2@mkp9GEQfkKdfoEgQp3l6rNSMfC1vV3jAxS7GKx2h0b@DUHur7CscJk95fzC0YPCya7@TywukyeXA/gzplE6uL2GF8v8Viz/hPzRcexx/vKeZ@k6CzhaQzy3xuS7KCTXaYkSAPgV/wSZfwVnCloBTK2679lye5HR4I26CoXTlhsKooqdHcBrKzARgMtAp@TH5FD8Cxyma7m0WGrKk3KqKguCCtXEuIPno1O98LzxP8FWUqEVucoOcI0AbsWkJ708xl5e4d5X/T27NM@jRUyFvexNpmd3v/jjl1/96d771w8@f3V/7PXJ57iHM5oz8yIApRakJVNnUK0lOSjpipBOKO7FFCDBrKisEo7hVwR38X1ml8gqjujq/NcNPW7/BazI8@oil9j3dWwnKawWpT1AqYv0zQNRDCpPXmyj840YHyvaFFbRz8VoiicMa3SiN1I6U6FtXZarkoMKH8dIAN8WBsovpLW6z8UqD3K1OfxTmiOqOo5RVmmGQ8Cs7mV96lWWxCtmSUC9gnYODb/ro/eVroXXZntlausYd9n11Zj39xvzvnPMs85Bz@xR5dA4yh3DcrBUKJzi2DFFfaqrOA0K7FBnRpvx6iYoBOpmfreWZU7dNHoC3ZniAn9vw@M0BMNdCC6bO44zpZPX7k5MS8ts9sDdTIzpOwYEKwHxjmorQ9EMhD5KkJw15z4S6UzTuabByjCEEO@0284AOK6I4nz5B38v60HTRQwtDPoZkuJ6RwX5DfaUIvq7aIkS6P@0vr0TbxaE4VAvHHmzvFwUeNIZNcfebFvGRbSLr42aU28WRm@jkBrll95sQ@M4/UeaxeY4P3izDJ08W9QT@4j0CfsBTRAUHvQQ1V6cMFpzTxCulAym57D0ITk7B5pGCSDg7jnbAj4ZkZxSMC3j9JKRKqRFEMVA6QWc0CBQUVGFFrzDXJ9QDgtHv5kxz7U3g/PUKPzGmwmO@y69TIzKb6vKv@2MqucwBi2e81qjbgfNssQc6Y43w8PSKF16M1B5loEJfYFrAM0KveFG1dybwVHnqPgMyJqGZZwa5X@AvkDbNkozXIFwurKz3Kg/92b1Fn78cwky04D4SaIn/Ds6H58mP3K54QQucEFIZOnCNuqHiDTo7BHoZg/NuQTA3@gvfppE1Q2AOcBDAfMMNPaAA/RZAUmrEgLm0PWCMo4Cds2iJfPUpfr29baASKy9ahvvR8RfTJfFEzAZmDfbAFhI0r5In9fqoAH0Z7Hsh0n4A@hobqBIAD0FXK@t2p@92c9lVAgt26h8KvbCU3TeGHUrYKQruiwL2kCTEKQBXZTr@hbKsiDw5/8VNZx5GFRhxT74oEx5YKKfSNl94vlCFmvAF/hh7tcHp2ltcvJtgzegglYykbltoyQHsQWlf/8rCI9lEMf8jhSMtjXIivu8PRxtEa8pIgC5JiUsDU3UBGZWst74wH3mlmfqrXDHL4OEpBlCKyPDoYODM/8I9DYi0ZiOwewoSAB0BBgQUcIjvU2za2GqACxWHK2OmBsfJVqQ1Do1RdsfZaawtarhmJ5okKzCHyOSrji23/91XkXad40dl5MtV5GNV4Mf7zZSuwi2L9cqNVE9hT05nRlIJKKjVtNitCrUZ1DPUpQH@66uGk/bP40egSfMFOFuAQeOLoyFz33bVN@n2UXT0HN5KzD3HFpuSGv8WlbQxx1aDitNvkmDt7zFG8Jxiy4Rs0HffVvKd8J4l@4GI8U7L5lG3LsGK/QRARBjHl7oOywR@ypb4ybL7dmGRNvhV3tHtV7n6rWCthtvqc@WPw53qjU71npazy7iOhjjo@0yk@@Nbe9g37ZL/GZfl3s8pzhz@A1vthv9/bdTrwkvja0aXY0f4G78GC5HNylcGOnczrqgERMN4dggXYeO0sBByqGTJn77HrFEmcMeFhLMNzzqvBgtYCB5w8ZxiIW@EKJidzqd1I3dNclcS9I6KdS6SudwxpKrCw7QMmlWNEx@Cv9HQ6fYlh4CVddwXKmIwBOmuKpq5ojwgUmEntnanMF4KfJzSUuqr7Upigj1x1qjH9QeLMmN8loQa1BnJ5sAQzhoItXO0PNNv6Ww/ZXeVluU27IfcRNk2/9DktAr9kn4b9A/woJDysVopWp0nG7oKkBIaJBHzPTP5aUP@V@apcyjXcMzT0LVgjsKxBkd0mW0BRVxkKVoAIR@Wz/SNyE6EtFd1R0CzDiLtihm2DFHA7AVqAhT7ClXu4AU604XEXWCfntPVy63hVSBpqoKtEUiMSkAAOit9aV6oTc60xohHfZodFdrxD2RjmY14dlsgBBIh/OJbnkYMaMwkgA0Rb0RYyJdoOq1NOk5gjR0jYphHnhwIxWMOF1XlQvRM5TZvQ@nE98/YDan08nx8WBxMh2JBcH8jq2ynsCQ2ALd2BFO0QlYmET8bRgU2tSMm3tXeEhTqAD0PhuxfTlXSMnXeavEtFDnDmPR2rDt6CASqRHbdIVSraX2U3KJ1GcFQ3KJRTxs7m2QRYG81@LY59pafx29BVn3CnXSIKtZSIjH/8GeeEeesonkzULV/n53@ztGBw6Kq42G5B9NrSZ2k41jnubNo7P3Y@z0ZOr7DrwGoUSoiFiswvgqh0kORyAUAuVQQip1HC3Mxc3ARGsL0M1wgjt9hVzn583bo1JEGxnt5LyiDnSncqB1ddEmqqwbDkSTdLkLXMmPbMlMTClokZWIN24jtWGuhq76@jgIHHUicMQQWB9Yt4tCfgMhEMg/8CWeSqqJUu4lU5GAsa1nKuYmYisOSdXEABeBOwI@xYDU9gaB/i7gZrg@PRfzbdrSOqyYbCNhTm@ds40zX1wbSe5GkOPziiyiOjqMMmqrfYnT0qadPv0DCXR8AIGOuwl0bO4cvPFT0X2Hne4s1OLWdpVCQHYZIKgn4quFXosoGCphnWBxFDQISZlTzRmthh70WXcasfFPToqgaG4nxJqUbO29sAkmrjAIR5Fbt7pjna7yjhtq55qG5KCfeR@uw8tIHcUA6ue0aFgPHnvwgYXrSxS1oWbvjgy2vwFqDFWzxlOX@mbiqWa76hpVRdI2fSuoLt@XlDsXDlxwjClYKEjeFBfTqFhhNJfoCBZ/754ZySXqNIeWHblhvokxLBLd0WDHinRMonEizWEk5oTcrhCFGnjj3U6PECD2owhC3h5NJg0kGe1Lknv3bk6TSQtJRoeSBCZk06GOIHDKDtla7HRjg6tobcdtO6fWtSIMxe/2o9WclCWa3GNWRW5LOFN6uZiqqW2z@P@gl6l1vI3fgTbngxEDeZkaL4UyUvF8IoLwAllFEJym7P0T1EUJrZ4Y8XjVnnA43iHo58AYTI6yaAuazhKOZhHEKhDz@NkTMuCX03B@p0l8zdqhwzvBx1P6Cy6/7alvgx7U9sZEXyePdFBXyktoAv/n1kkledrJF3ufYAfvhFYnCvd8WrFv3YdeWzeMJfjzGuGaWuIbZK6KifgebfNjoXhQClVkRPRNwqiclQl/hXOUy7iHqkEkeIZjO00UjQE4gWJojilQUBGUIZkDFsDwyucP6iIcIcDgirc0wzD9iE27oBincMirZZuUbc@0D@jZEfXqjnroCiRoikPQnsh2TMZ61HwY22rBhmpf8s7kQn2qYTLqUHY4ZCw2Dind4R@SFX3Jyl2PhJwjTz58wMYgVu6B@lvC39mG/KHtmDyPKYtMxzh@dkvHHkxipE1QFDFlQ@4yCr8frLdBFI@BbZi9FJBVdFU9@ozyvIRO8zRN7ni@He2LIeY1q6j2lBlh4KC63@/3Vd1FEzcY4ZNTJfaR262LDOhGC3alooT79BojRFXnoq2piCEV0WPrH@zOjZRJEcXcFovTHCOPxFQseHFP3vbMhEVIOwMz9np60gbYod1pgbINzzgFXW3cfFrIkVK7ksXs3RVZBDk//POiXK0UpQnUBPR7i3g2vNNK8Yk0rNZ1vO3B/3bQiO96XPRJbYubRVEczBqOqIpO6P@IHfQfgken0dNcwGMzeVy2qtBVwZxOdY4lEGEnFqtmmjGmD9DsI/JqqMBgXzzrAdOcWbIBZkasIp7bwdK13caTK51Ou3rjVM8aMus4Hijtrc/frgLXFYDqUkQtRU5GnYAtU2DIyR4vMc0mcpxDGjtCRGB/qtEdwipTtoNMRiIfzbz21Je37jH1zdR@xJ2319cvtF5jaI6IPdANpKn2JhIn@f7XmuR7ZZKW6WdN88GvNc0HyjTlCynfN7Jw1C/2bnOGIGyFTWu5OnxDIKqs1/LHr86V6vZGea/lAfgNMKQ1v@n8N8WJ1vzO5r8GL1rTuDsXfLkPF/ZuRWHNpMtE1cZ1jaoxVl69UZy2BRbvSzo825wwLi1QP1v2CuzHShPpetdK6gp1UoqxbC2uXwWtZNQIwO0bWXm0IVgIq8s071aAW/GJ8XA1j7WD8rg4//b22cGDk5GRLajhBUPlxTJI0QwtOaCJdoZ@U6s37SscEkw85FsbUCeW46y4YRC7zgg3tEHOb9jBBx5HnyYKDjrxPk0UHHyo/rbQwI/lpuPYcdL@pmyU37XB/xZtUGG7T0MxvPHObX8I2Nz0d4Xy36dQ/sqnlD79G/b1sXTWJzJxU7PiagSyskQZB4Xs8Sayqt7goqu7PvPt5mp0wGfkrn9YrHBX0ILW@d6BqUa7KkjVLWbaGk72f2oC8DLCwPVOA1OScPxXr9@wqCkMFONhq5iokDu4nQGT3X3s4RzvvrF3OLWbKUi3ux8x32FDiGR3jGljKlHs1kUSe8QqgLM7@rV9JDv4R88j49xUHKTOceGOadMT76s5wVnQtLqJ2cBmgpqD9jPbwWlGJkNxKZOkpIoK63qp1bZHJ84XaxqIWI4ZIOtMpKMsqjPCrSP@ycFkE9dcHXDVVuahS2omH/UdaZDnfRnbxoCU5IJ4IM/IKo52pxlmCMes2osoOd2AtB@wjDxvKEnoJWbOZ8GaQKWc@kN8rpluMYdhTgZ0vB6T6dmX0BJjqXgxBnAMyTKgeZCRfBOtCvk1GXVKIZU3VHprgYcsj7NgFij8wPBF1osjtvsmYYvOO@9GQtfxNcuNdQPjt6a@1ps13YnYD8o@cC5DvDQ997wbzUnvRHmzZiWNUrmABFP59EAkilqx97@UZb@MabIuNuq2dUXrQx8/8bT2InpB9IOAi7QoMDTJeipHgjNXmyCGbpOAJQ1KE1YZygmNhDSsHiHLxxo8XhCmNh3rIBOjfjImj@Oct@KKijq2lLXw8SiXJ2Q9PEucL@dHh7xbnCeLK4HZjBBQrA4z8YXhjIdZDzG1L0s6OiT7bQLXF7LslQFTPz16khM4GYyvliiYwVHlO@QB2JXlr8XEqe01aKbMOmPq9PyMdZ7lhygoqv70W105I10XY4@stQT3ynScW80hu/mXdDgOecdWcx9pF9WoRk/27M/U5AnbaL0peFbZM378q0tRDnjnUrjaERXLDTHDN7DK@AqRhjD/Gt3udO6sFzVzOx/Rd2UjUard8SfajCd28hfnK4GupZqaGN8eurdAQ@WkDY@T3/Go4dHpR3BnCK461iXNfwUuG5bcjlOZx9pIzCjeH5YJ6IkRfiNMTxEWZa5aC@ItwfUyxlMHNTvMSS@Ux5PR8elnQ/LDD4@fsGOGBll8DVgOKSIuwHwh2@DqdIs57cUfmHqK5@hYpnG5TU6z9HJIAugQZOYpmPI4TLm1vlKt4biyTpxmNagvps2R0WtM5Ssz0ZonQcMTDbsPJT14/WUM@q/mBz2OvJfG8xWnPXcHfzq/Qs1AYntknbAstQybh5hCDQMf9EBEP0mrr9nY/wWkbnW7nsxoyUFVVLNECSypsTCkFjz5PIoSplBgWf2FCa5HHEzXY5GDFL@dDFU3HoqIacwj2K4s3QipcgzUgbdKb2eiu/tKdyGQxdUX44wqFhFLq94SGsnX29iriGjkIq7FxoKWupllNpMRzg7lfI@v6rvJdxt2JVxX/dBTbyjSX8jlV0lDTNFxsInHVyUcoCLPfsP7SAVceH48j7gSmfQ6nOmts0KvvjGzlkmZ0MpD4/aneRxenpLml9k0BBY0tNTD2lTngZ6Yt@Gto/iaNn2jYgraNEFLjp1NbdzY@iz2Fr54wlh5rZ@4XjO6@wK1X0tn7@xOeRdapyvey/FiO2vFw7Oiw9ei7H9Eod7s3/hO1PRrNKLXjqLs2WeDktDZPvOawrQbZ9jw8ORs@sVXX/zp7pdffGWdUHWuCJY42p7D3g5yh5RUEW@b22kcvnBfKChfDKTZpvWnebs1friA3ee7yBqMbusrwg54yN75Uv2QuR0yP@ccWwTxPnPYZ2wr1cGBL/c/Fp2cz0Zsd77OsyZolSVFTVRTedBAcBkpUsgFal/COVdlR2FGC1O08LsvE5adCB/z8sziJMdv7ZmLhCFK5gAsF1kP0Z@3xmru3kNU4fMTBuGSsmEqlf1gi8oeP9sK45WKTH9iKujVruuv5U0MS/eIrdU5s2ktM8reiVcuSeZXhDZbXTbCDz4JfcS/QtPzvJe//OHd4pvzB8fvT0@PXx8vfoEyDUb@eTFDNaTHvzdbFsJJ/8vZvwA "Python 3 ‚Äì 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)
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~$192,450~~ $202,020 (~~9~~ 8 bytes)
```
O'$t+tMh
```
[Try it online!](https://tio.run/##K8gs@P/fX12lRLvEN@P/fwA "Pip ‚Äì 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)
```
[Answer]
# [Risky](https://github.com/Radvylf/risky), $200000 (8 bytes)
```
\*\!/**+:}!_\*+
```
[Try it online!](https://radvylf.github.io/risky?p=WyJcXCpcXCEvKiorOn0hX1xcKisiLCIiLDFd)
**Explanation:**
```
       +         ;  Join
   !             ;    Pair of
\*\              ;      "$" (6 * 6)
    /**          ;      "2" (5 * 10)
           _     ;    Fill
        :}!      ;      [1, 0, 2, 0, 1] (100 in base 3)
            \*+  ;      "0" (6 * 8)
```
[Answer]
# [Thunno](https://github.com/Thunno/Thunno) `KJ`, $93,648.04 (7 bytes)
```
AwaA^'$
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_WbSSt5dS7IKlpSVpuhbLHcsTHePUVSA8qOACKA0A)
#### 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
```
[Answer]
**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!
]


[Question]
      [
The program should take input the number, the start of the range and the end of the range, and output how many integers the number appears between the start and end of the range, **inclusive**. Both programs and functions are allowed.
## Example Inputs
For example:
```
//Input example 1
3,1,100
//Input example 2
3
1
100
//Input example 3
3 1 100
//Input example 4
a(3, 1, 100);
```
All the above four input examples are valid and all of them mean that `3` is the number in question, `1` is the beginning of the range and `100` the the end of the range.
And then the program should output how many times `3` appears in the range from `1` to `100` **inclusive**. `3` appears in the integers `3`, `13`, `23`, `30`, `31`, `32`, `33`, ..., `93` at a total of 19 times. So the program should output `19` as the output because that is how many times `3` appears in the range from `1` to `100`.
## Rules
* Both programs and functions are allowed.
* All numbers will be integers, meaning that there will **not** be any `float`s or `double`s.
* Note: the sought number will always be in the range `0≤x≤127`. There will be **no** cases where it will be outside this `0≤x≤127` range.
* As in the first example, with the case as `33`, the number `3` will be counted as appearing only **once**, **not** twice.
* The values of the start and end of the range will be between `-65536` and `65535` inclusive.
* The value of range's start will never exceed or equal to range's end. `start < end`
* Also the range is inclusive. For example if the input was `8 8 10`, the range would be `8≤x≤10` and hence the output will be 1.
* Input can be taken in any of the ways shown in the examples. Input can be taken as a string or as a number, any way you wish.
## Test Cases
```
3 1 100
19
3 3 93
19
12,-200,200
24          //This is because 12 appears in -129, -128, ..., -112, -12, 12, 112, 120, 121, 122, ...
123,1,3
0           //This is because all of 123's digits have to appear in the same order
3 33 34
2           //Because 3 appears in 2 numbers: 33 and 34
a(0,-1,1);
1
$ java NotVerbose 127 -12 27
0
```
# Snack Snippet
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 98470; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 41805; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });

  });

  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();

    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body { text-align: left !important}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```

[Answer]
# Bash, 20 bytes
the obvious answer
```
seq $2 $3|grep -c $1
```
example
```
$ bash golf 3 1 100
19
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 6 bytes
Input in the form: **upper bound**, **lower bound**, **number**.
```
Ÿvy³åO
```
Explanation:
```
Ÿ       # Inclusive range, [a, ..., b]
 vy     # For each element...
   ³å   # Check if the third input is a substring of the number
     O  # Sum up the results
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=xbh2ecKzw6VP&input=MjAwCi0yMDAKMTI)
[Answer]
## Perl, 20 bytes
*Saved 2 bytes by using `grep` as in @ardnew's [answer](https://codegolf.stackexchange.com/a/98490/55508).*
Bytecount includes 18 bytes of code and `-ap` flags.
```
$_=grep/@F/,<>..<>
```
Give the 3 numbers on three separate lines :
```
perl -ape '$_=grep/@F/,<>..<>' <<< "3
1
100"
```
[Answer]
# Python 2, ~~47~~ 43 Bytes
Relatively straightforward, making use of Python 2's `repr` short-form.
```
f=lambda n,a,b:a<b and(`n`in`a`)+f(n,-~a,b)
```
Ouput:
```
f(  3,    1, 100) -> 19
f(  3,    3,  93) -> 19
f( 12, -200, 200) -> 24
f(123,    1,   3) -> 0
f(  3,   33,  34) -> 2
f(  0,   -1,   1) -> 1
f(127,   12,  27) -> 0
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 thanks to [caird coinheringaahing](https://codegolf.stackexchange.com/users/66833/caird-coinheringaahing)! (Use `w` and filtering to avoiding `@`.)
```
rAwƇ⁵L
```
**[TryItOnline!](https://tio.run/##y0rNyan8/7/IsfxY@6PGrT7////XNTIw@A/ChkYA "Jelly – Try It Online")**
Input: Start, End, ToFind
### How?
```
rAwƇ⁵L - Main link: Start, End, ToFind
r      - range: [Start, ..., End]
 A     - absolute values
    ⁵  - third input: ToFind
   Ƈ   - filter keep those (absolute values, a) for which:
  w    -   first index of sublist (implicit digits of ToFind) in (implicit digits of a)
     L - length
```
The default casting of an integer to an iterable for the sublist existence check casts to a decimal list (not a character list), so negative numbers have a leading negative value (e.g. `-122`->`[-1,2,2]` which won't find a sublist of `[1,2]`) so taking the absolute value first seems like the golfiest solution.
[Answer]
## JavaScript (ES6), ~~46~~ 45 bytes
```
f=(n,s,e)=>s<=e&&!!`${s++}`.match(n)+f(n,s,e)
```
(My best nonrecursive version was 61 bytes.) Edit: Saved 1 byte thanks to @edc65.
[Answer]
## PowerShell v2+, ~~64~~ ~~62~~ 56 bytes
```
param($c,$a,$b)$(for(;$a-le$b){1|?{$a++-match$c}}).count
```
*-6 bytes thanks to mazzy*
Input via command-line arguments of the form **number lower\_bound upper\_bound**. A little goofy on the notation, because of the semicolons inside the `for` causing parse errors if it's not surrounded in `$(...)` to create a script block. We basically loop upward through `$a` until we hit `$b`, using `Where-Object` (the `|?{...}`) to pull out those numbers that regex `-match` against `$c`. That's encapsulated in parens, we take the `.count` thereof, and that's left on the pipeline and output is implicit.
---
If, however, we guarantee that the range will be no more than 50,000 elements, we can skip the loop and just use the range operator `..` directly, for **~~45~~ 43 bytes**. Since that's not in the challenge specifications, though, this isn't valid. Bummer.
```
param($c,$a,$b)($a..$b|?{$_-match$c}).count
```
[Answer]
# Vim, ~~46~~, 41 bytes
```
C<C-r>=r<tab><C-r>")<cr><esc>jC0<esc>:g/<C-r>"/norm G<C-v><C-a>
kd{
```
Input is in this format:
```
1, 100
3
```
[Answer]
## Haskell, 65 bytes
```
import Data.List
(s#e)i=sum[1|x<-[s..e],isInfixOf(show i)$show x]
```
The `import` ruins the score. Usage example: `((-200)#200)12` -> `24`.
[Answer]
# Java 7 85 bytes
```
int x(int a,int b,int c){int t=0;for(;b<=c;)if((b+++"").contains(a+""))t++;return t;}
```
[Answer]
# Swift 3, ~~96~~ 93 bytes
```
import Cocoa
func c(n:Int,s:Int,e:Int){print((s...e).filter{"\($0)".contains("\(n)")}.count)}
```
**Edit 1:**
Saved 3 bytes by using shorthand parameters
[Answer]
# Scala, 50 bytes
```
(c:String)=>(_:Int)to(_:Int)count(""+_ contains c)
```
takes the first input curried; call it like this: `f("12")(-200,200)`
Explantion:
```
(c:String)=>  //define an anonymous function taking a string parameter
  (_:Int)     //create a range from an anonymous int parameter
  to          //to
  (_:Int)     //another anonymous int parameter
  count(      //and count how many...
   ""+_       //elements converted to a string
   contains c //contain c
  )
```
[Answer]
# R, 32 bytes
Quite straightforward:
```
function(a,b,c)sum(grepl(a,b:c))
```
[Answer]
# C#, 71 bytes
Beat my Java answer thanks to lambdas
```
(t,l,u)=>{int d=0;for(;l<=u;)if((l+++"").Contains(t+""))d++;return d;};
```
[Answer]
# Ruby 44 bytes
```
m=->(n,s,f){(s..f).count{|x|x.to_s[/#{n}/]}}
```
Test Cases:
```
m.(3,1,100)     #=> 19
m.(3,3,93)      #=> 19
m.(12,-200,200) #=> 24
m.(123,1,3)     #=>  0
m.(3,33,34)     #=>  2
m.(0,-1,1)      #=>  1
m.(127,-12,27)  #=>  0
```
[Answer]
# PHP, 62 bytes
Pretty straight forward approach:
```
<?=count(preg_grep('/'.($a=$argv)[1].'/',range($a[2],$a[3])));
```
[Try it online](https://3v4l.org/3BBoO)
[Answer]
# C, ~~143~~ 135 bytes
Thanks to @Kritixi Lithos for helping save 8 bytes
Surely this can be done better, but its the best I've got for now. C doesn't handle strings very gracefully, so naturally it takes quite a few operations.
```
int C(int N,int l,int h){char b[99],n[99];int t=0,i=1;sprintf(n,"%d",N);for(;i<=h;i++){sprintf(b,"%d",i);if(strstr(b,n))++t;}return t;}
```
**Ungolfed + program**
```
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
int C(int N,int l,int h)
{
    char b[99], n[99];
    int t=0,i=1;
    sprintf(n,"%d",N);
    for(;i<=h;i++)
    {
        sprintf(b,"%d",i);
        if(strstr(b,n))
            ++t;
    }
    return t;
}
int main()
{
  printf("%d\n", C(3, 1, 100));
}
```
[Answer]
# JavaScript, ~~46~~ 45 bytes
```
f=(i,s,e)=>s>e?0:RegExp(i).test(s)+f(i,++s,e)
```
Recursively count until start > end
Edit: Switch to RegExp test to save a byte
[Answer]
# PHP, ~~68~~ 63 bytes
```
for($a=$argv;$a[2]<=$a[3];)$o+=strstr($a[2]++,$a[1])>'';echo$o;
```
use like:
```
 php -r "for($a=$argv;$a[2]<=$a[3];)$o+=strstr($a[2]++,$a[1])>'';echo$o;" 3 1 100
```
edit: 5 bytes saved thanks to Titus
[Answer]
# Powershell, 48 bytes
According to the rule, the range can contain more than 50,000 elements. So we can't use the range operator `..` directly. Thanks [AdmBorkBork](https://codegolf.stackexchange.com/a/98478/80745).
Straightforward:
```
param($c,$a,$b)for(;$a-le$b){$i+=$a++-match$c}$i
```
Test script:
```
$f = {
param($c,$a,$b)for(;$a-le$b){$i+=$a++-match$c}$i
}
@(
    ,(19, 3,1,100)
    ,(19, 3,3,93)
    ,(24, 12,-200,200)
    ,(0, 123,1,3)
    ,(2, 3,33,34)
    ,(1, 0,-1,1)
    ,(0, 127,-12,27)
    ,(44175, 0,-65536,65535)
) | % {
    $e,$a = $_
    $r = &$f @a
    "$($e-eq$r): $r"
}
```
Output:
```
True: 19
True: 19
True: 24
True: 0
True: 2
True: 1
True: 0
True: 44175
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~14~~ 8 bytes
Takes the integer to be found as the last input value.
```
õV èÈsøW
```
[Try it online](https://ethproductions.github.io/japt/?v=1.4.5&code=9VYg6Mhz+Fc=&input=LTIwMCwyMDAsMTI=)
---
## Explanation
```
             :Implicit input of integers U=start, V=end & W=number
õV           :Range [U,V]
    È        :Map
     s       :  Convert to string
      øW     :  Contains W?
   è         :Count truthy values
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `s`, 7 bytes
```
÷ṡƛS?hc
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=s&code=%C3%B7%E1%B9%A1%C6%9BS%3Fhc&inputs=%5B3%2C1%2C100%5D&header=&footer=)
[Answer]
# Java, ~~92~~ ~~89~~ 71 bytes
Now with lambdas!
```
(t,l,u)->{int z=0;for(;l<=u;)if((l+++"").contains(t+""))z++;return z;};
```
Old 89 byte function solution:
```
int d(int t,int l,int u){int a=0,i=l;for(;i<=u;)if((i+++"").contains(t+""))a++;return a;}
```
Hooray for the super increment function!
[Answer]
# Groovy, 48 bytes
```
{a,b,c->(a..b).collect{"$it".count("$c")}.sum()}
```
[Answer]
## Racket 91 bytes
```
(for/sum((i(range s(+ 1 e))))(if(string-contains?(number->string i)(number->string d))1 0))
```
Ungolfed:
```
(define(f d s e)
  (for/sum ((i (range s (+ 1 e))))
    (if(string-contains?
        (number->string i)
        (number->string d))
       1 0 )))
```
Testing:
```
(f 3 1 100)
(f 3 3 93)
(f 12 -200 200)
(f 123 1 3)
(f 3 33 34)
(f 0 -1 1)
```
Output:
```
19
19
24
0
2
1
```
[Answer]
# Axiom bytes 90
```
f(y,a,b)==(c:=0;for x in a..b repeat(if position(y::String,x::String,1)~=0 then c:=c+1);c)
```
results
```
(3) -> f(3,1,100)=19,f(3,3,93)=19,f(12,-200,200)=24,f(123,1,3)=0,f(3,33,34)=2
   (3)  [19= 19,19= 19,24= 24,0= 0,2= 2]
                                  Type: Tuple Equation NonNegativeInteger
(4) -> f(0,-1,1)=1, f(127,12,27)=0
   (4)  [1= 1,0= 0]
                                  Type: Tuple Equation NonNegativeInteger
```
[Answer]
## Mathematica, 70 bytes
```
(w=ToString;t=0;Table[If[StringContainsQ[w@i,w@#1],t++],{i,#2,#3}];t)&
```
**input**
>
> [12,-200,200]
>
>
>
**output**
>
> 24
>
>
>
[Answer]
## Clojure, 65 bytes
```
#(count(for[i(range %2(inc %3)):when(some(set(str %))(str i))]i))
```
[Answer]
## PHP, 56 Bytes
run as pipe
[**Try it online**](https://tio.run/##K8go@G9jX5BRoMClkliUXqZgqxBtrGOoY2hgEGvNZW8HlLQtLk0qLimKT84vzSvRyMrPzNMoSsxLT9XQUEm0BWvSjDaM1VFJjDaK1dQE0Qaxmtb//wMA)
**Input**
```
$argv = [number_to_find, range_start, range_end];
```
**Code**
```
<?=substr_count(join(range(($a=$argv)[1],$a[2])),$a[0]);
```
**Explanation**
```
#substrcount, counts the aparitions of a subtring in a string
substr_count(
           join( range(($a=$argv)[1],$a[2])), # String with the range
           $a[0]);                            # The number you are looking for
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 32 bytes
```
{+grep *.contains($^a),$^b..$^c}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1o7vSi1QEFLLzk/ryQxM69YQyUuUVNHJS5JT08lLrn2f3FipUKahrGOgiEQGRho/gcA "Perl 6 – Try It Online")
]


[Question]
      [
## Introduction:
I think everyone knows what a Lava Lamp is, but in case they do not:
[![enter image description here](https://i.stack.imgur.com/dILgU.gif)](https://i.stack.imgur.com/dILgU.gif)
[(Image source)](http://api.ning.com/files/qrbliHRnvdw1Rjlr3hjMBmZV8cArQzQHkjqIHMFYV8KWdSCn2lBsAOS6i8s6TltTPjR1JKi9OOFVeYuHqDer7HzWmrvpdteJ/1614584823.gif?xgip=108%3A0%3A324%3A324%3B%3B&width=48&height=48&crop=1%3A1)
They're basically glass tubes that contain wax in a translucent liquid. The bottom part is heated when the lamp is turned on, causing a change in density and thus the wax floats to the top. When it cools down, it falls down again, causing the effect we see above.
It usually takes about 45-60 minutes for the base of the lamp to rise in temperature high enough to change the solid wax to liquid wax (if the lamp is located in an area at room temperature).
[More information on Wikipedia, which is also used as source for some of the text above.](https://en.wikipedia.org/wiki/Lava_lamp)
## Challenge:
Given a positive integer `n` indicating the amount of minutes that have passed since we've turned the Lava Lamp on, output a random state of the Lava Lamp based on integers on five levels.
For this challenge we'll say the Lava Lamp contains 1000 units of wax in total, and we have five levels where the wax can be at.
1) If `n` is below 45, the Lava Lamp is still heating up, so the output will be four empty lines with `1000` at the bottom:
```
1000
```
2) If `n` is in the range `[45, 60)` the Lava Lamp has increased in temperature enough for wax to move around, but no very high yet. The wax can reach up to and including the third level.
3) If `n` is `60` or higher, the wax can be at any of the five levels.
So given the positive integer `n` as input, we'll output a [random](https://codegolf.meta.stackexchange.com/a/1325/52210) state with the three rules above in mind.
**Here are some example outputs:**
Possible outputs for any `n` that is `>= 45`:
```
523
106
371
```
```
913
87
```
Possible outputs for any `n` that is `>= 60`:
```
73
113
312
5
497
```
```
284
55
637
24
```
Constant output for `n` that is `<= 44` (and possible output for any `n`):
```
1000
```
## Challenge rules:
* There can be empty lines, even though the level above it is not empty.
* Just `0` isn't allowed on any line. Should be empty instead.
* Output is somewhat flexible. You are allowed to output a list/array of strings/objects instead of a new-line delimited result as above. The reason I say strings/objects is due to the rule above. An empty line should be `""`, `null`, `[]`, etc., but cannot be `0` or a negative integer (nor can it be `false`) (I.e. `["", "", 913, "", 87]` for `n >= 45`). You are also allowed to reverse the output (I.e. `1000\n\n\n\n` instead of `\n\n\n\n1000` or `[87, null, 913, null, null]` instead of `[null, null, 913, null, 87]`).
* The numbers should all be integers. The can be decimals with `0` as decimal value, but none of the numbers should have any decimal digits, and the integers should always sum to exactly `1000`.
* All possible [random](https://codegolf.meta.stackexchange.com/a/1325/52210) outputs based on `n` should have a non-zero chance of occurring.
* A trailing new-line (so there are six lines of output) is allowed.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, adding an explanation for your answer is highly recommended.

[Answer]
# [Python 2](https://docs.python.org/2/), ~~117~~ ~~113~~ ~~108~~ ~~107~~ ~~106~~ 105 bytes
```
from random import*
def f(n):a=['']*5;exec"i=randint(0,(n>44)+(n>59)<<1);a[i]=(a[i]or 0)+1;"*1000;print a
```
[Try it online!](https://tio.run/##RYyxDoMgFEV3v4K4yNMOiEq1aH/EOJAqkUEwhKH9evpkcTn35eS@e/7C7iyPUXt3EK/simGO0/lQZuumiaYWXmqai2IpO7l9t09upqtnbKDsQe27baHC6AYYxxqkms0y0YvOEwZVLfOyZozJ0@MLUVFTBpmmDTIpvHHiYpfY3x43kSL1Bb@94LwZ@vYJ8Q8 "Python 2 – Try It Online")
Returns a reversed list (bottom first)
---
Version inspired by the stackoverflow [answer](https://stackoverflow.com/a/8064754/1682559) in the comments (edgecases are more likely):
# [Python 2](https://docs.python.org/2/), 129 bytes
```
from random import*
def f(n):a=sorted([1000]*5+sample(range(1001)*5,(n>44)+(n>59)<<1));print[y-x or''for x,y in zip([0]+a,a)[:5]]
```
[Try it online!](https://tio.run/##RYxBDoIwEEX3nKI7ZwCTUigCohchLJpAtYm0TWEBXh5HNmzen7zM/35b3s6KfdfBTSwoO1CYybuwxNEwaqbBYqMeM4lxgC7jnPexTGY1@c8IVHiNQDLDWKZgn0WBCYWssW0zxLsPxi7ddl2ZC5eLdoGt6caMZV/joeN9olKFXSP7ftfAMdKQE48W3bT2pzxYnZ7mieXxX4rTl0LkdVXccP8B "Python 2 – Try It Online")
[Answer]
# JavaScript (ES6), 78 bytes
Returns a reversed array where empty levels are filled with a space.
```
t=>(a=[...'     '],g=k=>k?g(k-1,a[Math.random()*(t>59?5:t<45||3)|0]++):a)(1e3)
```
[Try it online!](https://tio.run/##ZcxNDoIwEEDhvadwx4xAA6E1Qmw5gScgLCb8KtgaaFz17lWXpm/5Ld6D3rR32/1lU236wY/SW6mAZMMYi46/ojaZ5CLVUk@wpHlCzY3szDbSvXkCnsAqUdaislcunCvQZW0cY0UI@VCg74zezTqw1UwwQoZ4@BfOQxIBiTKgc/i6fMl/AA "JavaScript (Node.js) – Try It Online")
### Commented
```
t => (                      // t = input
  a = [...'     '],         // a[] = output array, initially filled with 5 spaces
  g = k =>                  // g = recursive function taking an iteration counter k
    k ?                     //   if k is not equal to zero:
      g(                    //     do a recursive call:
        k - 1,              //       decrement k
        a[                  //       update a[]:
          Math.random() * ( //         pick a random slot:
            t > 59 ? 5 :    //           among all 5 slots if t > 59
            t < 45          //           force the 1st slot if t < 45
            || 3            //           among the 3 first slots otherwise
          ) | 0             //         round the above result to an integer
        ]++                 //       increment the wax amount on this slot
      )                     //     end of recursive call
    :                       //   else:
      a                     //     stop recursion and return a[]
)(1e3)                      // initial call to g() with k = 1000
```
[Answer]
# [R](https://www.r-project.org/), ~~85~~ 84 bytes
```
function(n)write(ifelse(t<-table(cut(runif(1e3,2*(n<60)+3*(n<45),5),0:5)),t,""),1,1)
```
-1 byte thanks to @Giuseppe
[Try it online!](https://tio.run/##JYpBCsMwDATvfUZOUquA3TQ5FH8mCRIIglpcmT7ftRtYhh12c5U0Vim2u74MDL9ZnUGFjw@Dp9HX7WDYi0MupgKRJ7pfwdIS8Db18piRWsJzRiSnYUCKFLG@s5pDwIt0nNa@TTtPX/5zY/0B "R – Try It Online")
Explanation (ungolfed):
```
function(n){
      # Generate 1000 random uniform numbers in [5,5] (if n<45),
      # in [2,5] (if 45<=n<60) and in [0,5] (if n>=60).
    x = runif(1e3,2*(n<60)+3*(n<45),5)
      # Code each by the number of the interval it falls in (0,1],(1,2]...(4,5]
    cx = cut(x,0:5)
      # Tabulate the intervals. Because cut() returns a factor,
      # zero counts are included
    t = table(cx)
      # Vector-wise replace zero elements with "" and cat out, 1 per line.
    t1 = ifelse(t,t,"")
    write(t1,1,1)
}
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~131~~, ~~116~~, ~~90~~, ~~89~~, 87 bytes
```
L(l,a,v,A){for(A=5,v=1e3;A--;v-=a)printf("%d\n"+!a*2,a=l>59|A<3&l>44?rand()%-~v:!A*v);}
```
[Try it online!](https://tio.run/##VY7NUoMwFIX3PMVtHZwEEodacGxDcNi3T6AuYvhpahocoHFR8dGN0OqiuzPfPd@dI2ktpbtRRupjUULa9YVq7naZd4W0ertmvTqUI3EbpIkgluT4VDUtynlCLF@US5ZTyizlAn@0yvQVmvvFi5mHMxHcE8F1lqy@8nR5q7M4fmqFKRD26bddz/LAYja40YGDUAZNQbS1JHInWgiCMVsMJw@gO2tSN/IdYcxGMi2Y@opHDMJQpZPILm2A6bLnom8Ump48q9ezBPC/cKvMsS/BL9bjUgL7v/MGXdLgDc4tEhfHLk5csnIPkXuMfmSlRd05@vkL "C (gcc) – Try It Online")
**Update**: Fixed a bug in the original. Fused in the helper function, reducing an additional 15 bytes.
**Update 2**: -25 bytes thanks to ErikF.
**Update 3**: -1 byte thanks to ceilingcat.
## Degolf
```
L(l,a,v,A){
    for(A=5,v=1e3;A--;v-=a)
        printf("%d\n"+!a*2, // No clue how this works anymore, but it'll advance the pointer
                            // to the string constant when a number shouldn't be printed.
        a=l>59|A<3&l>44?rand()%-~v // Random integer to print in [0, v]
        :!A*v); // If bottom layer, return remaining volume
}
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~21~~ 20 bytes
```
5º*♪{k[K∞╟(]m<Σ∞wΦ}σ
```
[Try it online!](https://tio.run/##y00syUjPz0n7/9/00C6tRzNXVWdHez/qmPdo6nyN2Fybc4uB7PJzy2rPN///b8BlYsJlYsplasllZsBlaGAAAA "MathGolf – Try It Online")
This is my first answer in my new language. I based my solution on Emigna's 05AB1E solution, but used some neat features of MathGolf to make it a tiny bit shorter.
## Explanation
```
5º*                   push 5, [0], multiply (yielding [0,0,0,0,0]
   ♪                  push 1000
    {                 start block
     k                push input as integer
      K∞              push 22 and double it, yielding 44
        ╟(            push 60 and decrease, yielding 59
          α           wrap last two elements in array, yielding [44,59]
           m<         map is less than, giving [0,0], [1,0] or [1,1]
             Σ        sum array, giving 0, 1 or 2
              ∞       double, giving 0, 2 or 4
               w      push random integer in range
                Φ     increase array element
                 }    execute for loop (loops 1000 times)
                  σ   convert to string and remove leading zeroes (implicit map)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~27~~ ~~26~~ 25 bytes
Saved a byte thanks to *Adnan*.
Saved another byte thanks to *Kevin Cruijssen*.
```
5Å0₄FD„,;ÇI‹O·ÝΩ©è>®ǝ]ε0Û
```
[Try it online!](https://tio.run/##ATYAyf9vc2FiaWX//zXDhTDigoRGROKAniw7w4dJ4oC5T8K3w53OqcKpw6g@wq7HnV3OtTDDm///NTk "05AB1E – Try It Online")
**Explanation**
```
5Å0                         # initialize with a list of 5 zeroes
   ₄F                       # 1000 times do:
     D                      # duplicate the list
      „,;ÇI‹                # check if the input is larger than 44 and/or 59
            O·              # sum and double, yielding (0,2 or 4)
             ÝΩ             # pick a random number between and 0 and the number above
               ©è           # get the count in that level
                 >          # increment it
                  ®ǝ        # insert it at the same position
                     ]      # end loop
                      ε0Û   # remove leading zeroes on each level
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~87~~ 86 bytes
```
f=(n,w=1e3,s=5,r=n<45|n<60&s<4|s<2?w:Math.random()*w|0)=>s?`${r||""}
`+f(n,w-r,s-1):""
```
[Try it online!](https://tio.run/##hc7fCsIgHIbh812GRGjp2EoHLW1X0D1Mttkfloa/kQfZtRsdFsFOPx4@3qt@aOj85T4x6/ohJaOwpUGVw5aCEtQrK7mIVlbFEiSPIDdNqI96Oude297dMFmFWBB1gKZdPH2MCL2ydm0@L8xTYCWpEUr7rHMW3DjkozthgwtCvifyKzifJ2KWiN0sqf60pDc "JavaScript (Node.js) – Try It Online")
The 83-byte solution (`(n/15-2|0)*s<4`) is reserved first because I need to check for larger `n`.
UPDATE: Yeah, `(n/15-2|0)*s<4` didn't work because for larger `n` because `n` large enough makes the sum fail to reach 1000.
[Answer]
# PHP, 92 bytes
```
$i=5;for($n=1e3;$i--;$n-=$x)echo($x=rand($i?0:$n,$i<($argn<60?$argn<45?:3:5)?$n:0))?:"","
";
```
Run as pipe with `-R` or [try it online](http://sandbox.onlinephpfunctions.com/code/218896eb2ea7e4780ca690544349f6ead123293c).
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 215 bytes
```
import StdEnv,Math.Random,Text
? ::!Int->Int
?_=code{ccall time "I:I"
}
$n#l=take(max(2*min(n/15-2)2)0+1)(genRandReal(?0))
#l=map toInt[1E3*e/sum l\\e<-l]
|sum l==1000=map(\v|v>0=v<+"\n"="\n")(l++repeat 0)%(0,4)= $n
```
[Try it online!](https://tio.run/##JY/BS8MwGMXv@StinZCsrUurXsqyXtyhoCCbNyvykWazmHwpXVYmzn/d2Orl8X7w3oOnjAYM1jVHo6mFFkNrO9d7uvXNGofkEfz79QawcTZ51idPSloUFxX6dDUKKd@kco3@UgqMob61mkZVUUXkm8zw0kgPH5pZOLF8bltkuMju0pznXMQZZ3uN0/JGg2Gl4JyMBQsd9W6cfsnWN3O9OBwtNXWtl6l5Jec/kjITQkxJVg/nYSXksIyjGiM5CWcmjnvdafBU8Csmklsu6QzD1sN4a7R0qocftTOwP4S0egj3nwi2Vf/wZMDvXG9/AQ "Clean – Try It Online")
So I've finally found a shorter way to get a random seed than importing `System._Unsafe`, `System.Time` and using `toInt(accUnsafe time)`...
And boy is it truly in the spirit of codegolf - embedding a call to C, ignoring the world state type normally used to ensure the evaluation order of such things.
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), ~~121~~ ~~117~~ ~~113~~ 111 bytes
```
m->{for(int w=1000,j,i=5;i-->0;w-=j=i>0?j*=Math.random():w,System.out.println(j<1?"":j))j=m>59|m>44&i<3?w+1:0;}
```
[Try it online!](https://tio.run/##bVA9T8MwEN3zK04ZUEIbyxWtBE2cDIiBgalsiMGkSXsmtiP70oBKf3twq4qJJ52edF/v3Sl5kJnafk51J72H18YTHKMIoB8@OqzBk6RAB4tb0BJNsiGHZvf2DtLtfAq0d3b08PRVNz2hNWEYAlRYywbCjrWDqc8F9miNH3TjimdDza5xJbQgYNJZeWytS9AQjGLBOZ@rOYpVjllW8nzMhBJY8krdihdJe@ak2VqdpOtxvvn21GhmB2J9MEWdSVSxqOJ4rdJUCV2uHn50uVzeYHFXjbPFmuenKY8uBoMkXDQxmOB5oALuLzwTsEqvZwD8oxFaIIbsD3GaX5tbJuvzHxK8pk7ROU7TLw "Java (JDK 10) – Try It Online")
It's biased towards putting more wax near the top, but it's theoretically possible for any legal arrangement of wax to appear.
edit: 4 bytes were saved by [@KevinCruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
# In Human-readable Java:
```
(int minutes /* golfed variable m */) -> {
  int waxRemaining = 1000; // golfed variable w
  // golfed version goes from index 4 to 0 in a bit of a roundabout way
  // starting at 5 but decrementing right away
  for (int level = 4 /* golfed variable i */; level <= 0; level--) {
    // golfed variable j
    // the golfed version initializes this to (waxRemaining + 1)
    // in order to juice out some extra bytes during the Math.random() call
    int waxAtLevel = 0;
    // the golfed version does all of these ifs as ternary operations
    // and avoids using 2-character operators wherever possible
    // so e.g. "a == 0" becomes "a<1" and "a && b" becomes "a&b"
    // since here we are certain things can't be negative,
    // and took a good look at the Java operator precedence cheat-sheet
    // to make sure "&" and "|" would work properly to give a truthy value
    if (level == 0) {
      // if we are at the bottom level, just put the rest of the wax there
      waxAtLevel = waxRemaining;
    } else if (minutes >= 60 || (minutes >= 45 && level < 3)) {
      // otherwise if we are at a legal level put a random portion of the remaining wax there
      // note: the random portion can be between 0 and waxRemaining inclusive
      waxAtLevel = (int) (Math.random() * (waxRemaining + 1));
    }
    if (waxAtLevel > 0) {
      // only print the amount of way at this level if its greater than 0
      System.out.print(waxAtLevel);
    }
    System.out.println();
    waxRemaining -= waxAtLevel;
  }
}
```
[Answer]
# [Powershell](https://docs.microsoft.com/en-us/powershell/), 188 162 bytes
```
param($m);$t=0;$a=,0*5;$s=if($m-lt45){4}elseif($m-lt60){2}else{0};$s..4|%{$t+=$a[$_]=if($_-eq4){1e3-$t}elseif($t-ne1e3){Random(1000-$t)}}$a|%{if($_){$_}else{''}}
```
[Try it online!](https://tio.run/##PYzLCsIwEEX3fsdIO2rKVNO6KPkJtyIl4IhC@rANuBjz7TFUdHvuPWccXjzNd3YuxtFOtsuhwwa8oQas2dGmamA2j1vCynldoejAbuYfqQllvxChkK5Fod9rAb81YM/QXha1VfzUKCUfFPi/7lXPCaGcbH8durwkorRjCCuwKbKYKNB@81kWQoyxPn4A)
-2 bytes by @Kevin Cruijssen
-4 bytes by removing optional Get- verb
-20 bytes by shortning loop and removing spaces
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), ~~192~~ 190 bytes
```
var n,a:word;z:array[0..4]of word;begin read(n);if n>44then a:=a+3;if n>59then a:=a+2;Randomize;for n:=0to 999do inc(z[random(a)]);for n:=0to 4do if z[n]>0then writeln(z[n])else writeln end.
```
[Try it online!](https://tio.run/##TcxBDoIwEEDRq8yyjUqIlkXbwCHcEhYjbbUJTkkhEnv5Khij25efP@LU43BwY5/zAyPQHtUSotFJYYz4bMuiEF1wsOHFXj1BtGgYce0dUCPEfLMEqGrcnT5UyR8d9RnJhLtPVrvw/qu6nANIKU0ATz1LbdwChrzj/4lYAweppa4pt@ES/WwHYitxO0z2K2DJFDmLqnoB "Pascal (FPC) – Try It Online")
Using [packing into bins method by TFeld](https://codegolf.stackexchange.com/a/171985/60517). Prints bottom row first with a trailing newline.
It seems that FPC doesn't have problems with `random(0)`, so I have some unusual adding there.
---
My original submission, golfed down to 209 bytes:
```
var n,i,a,r:int32;begin read(n);if n>44then a:=a-2;if n>59then a:=a-2;r:=1000;Randomize;for i:=-3to-0do begin if i>a then begin n:=random(r+1);if n>0then write(n);r:=r-n;end;writeln;end;if r>0then write(r)end.
```
[Try it online!](https://tio.run/##VY5LDsIwDAWvkmURDUp/CxKlh@AGpknBUnEqE4HE5UtIWMDOGr959gr3CRY5r9O2PYAF1VhDzRopdq05@wuSYA@uop3BWdDY9/HqSYC2INuChuMvYm0bpZQ5Ablww5c3c2CB2souBqlcEKU1qTiCyGohpC1nqeJ98z2n8v7JGP3nhVTOkownZzJbypyi/BflXcKHbeuH4Q0 "Pascal (FPC) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 28 bytes
```
>“,;‘SḤ‘µȷŻṗS⁼¥ƇȷX;0ẋ5¤ḣ5Yḟ0
```
A full program printing the result (upside down, as has been allowed).
**[Try it online!](https://tio.run/##AUEAvv9qZWxsef//PuKAnCw74oCYU@G4pOKAmMK1N8W74bmXU@KBvMKlxoc3WDsw4bqLNcKk4bij4bmaWeG4nzD///81OQ "Jelly – Try It Online")** - this is altered to use `7` rather than `ȷ` (1000) because the implementation is golf-tastically slow! (...for \$n>59\$ a list of \$10^{15}\$ 5-tuples is built and then filtered, from which to choose)
### How?
```
>“,;‘SḤ‘µȷŻṗS⁼¥ƇȷX;0ẋ5¤ḣ5Yḟ0 - Main Link: integer, n
 “,;‘                        - list of code-page indices = [44,59]
>                            - greater than? (vectorises)
     S                       - sum (i.e. 0, 1 or 2)
      Ḥ                      - double (i.e 0, 2 or 4)
       ‘                     - increment (i.e. 1, 3 or 5)
        µ                    - start a new monadic link, call that x (i.e. f(x))
         ȷ                   - literal 1000
          Ż                  - zero-range = [0,1,2,...,1000]
           ṗ                 - Cartesian power (all tuples of length x using those numbers)
               Ƈ             - filter keep if:
              ¥              -   last two links as a dyad:
            S                -     sum
             ⁼  ȷ            -     equals 1000? (i.e. only valid tuples)
                 X           - random choice (get one of these tuples)
                      ¤      - nilad followed by link(s) as a nilad:
                   0         -   zero
                    ẋ5       -   repeat five times = [0,0,0,0,0]
                  ;          - concatenate     (e.g. [354,388,258,0,0,0,0,0])
                       ḣ5    - head to index 5 (e.g. [354,388,258,0,0])
                         Y   - join with newlines
                          ḟ0 - filter out zeros
                             - implicit print
```
[Answer]
# [Twig](https://twig.symfony.com/), 126 bytes
This was an actually fun challenge!
This code creates a macro that has to be imported.
```
{%macro a(s,z=1000)%}{%for _ in 4..1%}{%set t=s>59or(s>44and _<3)?random(z):''%}{%set z=z-t%}{{t}}
{%endfor%}{{z}}{%endmacro%}
```
To import it, just do this:
```
{%- import 'macro.twig' as a -%}
{{- a.a(50) -}}
```
This should do the trick.
You can try it on <https://twigfiddle.com/t4dfgy>
**Notice**: Due to the page removing whitespaces, I was forced to add an `-` at the end of the line, to prove that it is outputting the correct number of lines.
On a regular installation, you would just see the newlines without issues.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 62 bytes
```
{($!=1e3)||@,|((+$!-($!-=$!.rand+|0)||@)xx($_/15+|0)*2-4)[^4]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1pDRdHWMNVYs6bGQadGQ0NbRVEXKKRrq6KoV5SYl6JdYwCS0qyo0FCJ1zc0BfG1jHRNNKPjTGJr/6flFykY6Bga6JgAkamOqYGOmYGOuYFCNZeCQnFipYJKvIKtnYIe0C6uWq7/AA "Perl 6 – Try It Online")
An anonymous code block that takes a string and returns a list of integers, with `Nil` or an empty list (`[]`) in place of `0`s.
### Explanation:
```
{($!=1e3)||@,|((+$!-($!-=$!.rand+|0)||@)xx($_/15+|0)*2-4)[^4]}
{                                                            }  # Anonymous code block
 ($!=1e3)  # Initialise $! to 1000
                +$!-($!-=$!.rand+|0)     # Pick a random value from 0 to $!
                                    ||@  # Or an empty array if it is zero
            ,  (                       )xx  # Repeat this
                                          ($_/15+|0)*2-4  # The given value mapped to 0,2,4
             |(                                         )[^4] # Get the first four values
 ($!    )||@  # Where the first value is the leftover number in $! or an empty array
```
[Answer]
# [PHP](https://php.net/), ~~113~~ ~~108~~ ~~99~~ ~~97~~ 93 bytes
```
<?php $i=$argv[1];while($a++<1e3){${r.rand(1,$i<60?$i<45?:3:5)}++;}echo"$r5
$r4
$r3
$r2
$r1";
```
[Try it online!](https://tio.run/##K8go@P/fxr4go0BBJdNWJbEovSzaMNa6PCMzJ1VDJVFb28Yw1VizWqW6SK8oMS9Fw1BHJdPGzMAeSJqY2lsZW5lq1mprW9emJmfkK6kUmXKpFJkAsTEQGwGxoZL1////TQ0MAA)
-11 bytes thanks to @titus
-9 bytes because everything is a string
[Answer]
# [J](http://jsoftware.com/), ~~56~~ ~~55~~ ~~54~~ ~~48~~ ~~43~~ 40 bytes
```
5{.1e3(2<@-/\[,0,~[:\:~?@$~)2*1#.>&44 59
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/Tav1DFONNYxsHHT1Y6J1DHTqoq1irOrsHVTqNI20DJX17NRMTBRMLf9rcnEVpRaWZhalKqjnleamFmUmq3MVJeal5OdmVqWqq3NxpSZn5CukKRjAGCYmcJYpjGUGlzU0MOD6DwA "J – Try It Online")
*-3 bytes thanks to FrownyFrog*
---
Another conceptually nice method that's a bit longer but guarantees perfectly uniform distribution over all possibilities, per [the method here](https://math.stackexchange.com/a/1276225/20688):
### [J](http://jsoftware.com/), 53 bytes
```
5$!.a:[:<@(+/);._1 0:,(1e3#1)({~#?#)@,0$~2*1#.>&44 59
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/TVUU9RKtoq1sHDS09TWt9eINFQysdDQMU42VDTU1quuU7ZU1HXQMVOqMtAyV9ezUTEwUTC3/a3JxFaUWlmYWpSqo55XmphZlJqtzFSXmpeTnZlalqqtzcaUmZ@QrpCkYwBgmppgsM7ispSXXfwA "J – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~115~~ ~~105~~ 98 bytes
-17 bytes thanks to mazzy
```
$a=,0*5
45,60-ge"$args"|%{$i+=2}
$i..4|%{$t+=$a[$_]=random(1001-$t)}
$a[4]+=1e3-$t
$a|%{"$_"*!!$_}
```
[Try it online!](https://tio.run/##Lcq7CoMwGEDhPU@h4W9tvRHbqCBk6tK5SwcRDRgvELVEoYP12dP0Mp6P85ieQs2dkFJDw1YNnPnEjRGN/YQErcDAVTvj126F3mOnDUEfhvSTi8eA51AWTPGxnoZDREgUwHI0D89p4bFInE2bMjuGEru2DeWmN@Rcul7KzEF7aCxKEcLVeOdqyPBPkq/cRG1dp@WPaarf "PowerShell – Try It Online")
A golf of [Edwin's lovely answer](https://codegolf.stackexchange.com/a/172142/78849). If you like this, upvote him.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~37~~ 36 bytes
```
Ｆ²Ｆ²⊞υ∧‹³⁺ι÷Ｉθ¹⁵‽⊕⁻φ↨υ¹⊞υ⁻φΣυＥυ⎇ιＩιω
```
[Try it online!](https://tio.run/##TY3LCsIwEEX3fsUsJxCh9bEQVz42BQtF/YHQjDTQTjWPil8fm0rB2dzFnHtP3Shb96qN8dFbwJWAOavgGgwSDqzxQs7hWkLVBodGQsH@bAajCU/KeXwJCflWiDGuinXfYcG1pY7Yk8bS8NjKsyyTcFSO0mguptsvZss/dAsdht/XGvZYqmdC7mRZ2U/yT1Yz6t4Ji3Gzi8uh/QI "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 1 byte by converting the empty list from base 1 instead of trying to sum it. Explanation:
```
Ｆ²Ｆ²
```
Loop twice, twice. Alternatively I could have integer divided the loop index by 2 for the same byte count.
```
‹³⁺ι÷Ｉθ¹⁵
```
If the outer index plus a fifteenth of the temperature is greater than three...
```
⊞υ∧...‽⊕⁻φΣ∨υω
```
... then push a random integer up to and including 1000 - the sum so far. Unfortunately Charcoal can't calculate the sum of an empty list so I have to convert from base 1 instead.
```
⊞υ⁻φΣυ
```
Push the leftover amount to the list. (The sum is safe here because the list is no longer empty.)
```
Ｅυ⎇ιＩιω
```
Convert the list to string, but use the empty string instead of zero.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~62~~ 55 bytes
```
->n{w=1000;[4,4,3,3].map{|r|r*15>n||w-=q=rand(w);q}<<w}
```
[Try it online!](https://tio.run/##Nco7CoAgAADQvVM0VmgofkBKLyIORrglJYREdnYjtOktL5zLlZ3MUPk7SowQmjQFFBBAzLjZ/U4hhQEz5VOKUB4yWL92sZ@OZ57jk/fWaWSaD1KltMqK7FcUeX0cF4Uw@QU "Ruby – Try It Online")
Tests are limited to 0-99 degrees, because lava lamps could be [dangerous](https://www.youtube.com/watch?v=_rjkvQo_FDQ) at higher temperatures:
]