Mentre faccio domanda per alcuni lavori il cui annuncio di lavoro non indica lo stipendio, ho immaginato un intervistatore particolarmente malvagio che avrebbe dato al candidato la possibilità di decidere il proprio stipendio ... "giocando a golf"!

Quindi va semplicemente così:

Senza utilizzare i numeri, scrivi un codice che genera lo stipendio annuale che desideri offrire.

Tuttavia, essere in grado di scrivere codice conciso è una pietra angolare di questa azienda. Quindi hanno implementato una scala di anzianità molto stretta dove

i datori di lavoro che scrivono codice che è lungo b byte possono guadagnare un massimo di ($ 1'000'000) · b ^-0,75 .

stiamo osservando (queste sono le parti intere, solo per motivi di visualizzazione):

   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

La sfida

Scrivi un programma o una funzione che non accetta input e genera un testo contenente un simbolo di dollaro ( $, U + 0024) e una rappresentazione decimale di un numero (intero o reale).

• Il tuo codice non può contenere i caratteri 0123456789.

Nell'output:

• Opzionalmente può esserci un singolo spazio tra il simbolo del dollaro e il numero.

• Gli spazi bianchi finali e iniziali e le nuove linee sono accettabili, ma è vietato qualsiasi altro output.

• Il numero deve essere espresso come un numero decimale utilizzando solo i caratteri 0123456789.. Ciò esclude l'uso della notazione scientifica.

• È consentito qualsiasi numero di cifre decimali.

Una voce è valida se il valore che emette non è maggiore di ($ 1'000'000) · b ^-0,75 , dove b è la lunghezza in byte del codice sorgente.

Esempio di output (le virgolette non devono essere 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

Il punteggio

Il valore che hai emesso è il tuo punteggio! (Il salario più alto vince, ovviamente.)

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, $X (Y bytes)

dov'è il Xtuo stipendio ed Yè la dimensione della tua presentazione. ( Y bytesPuò essere ovunque nella tua risposta.) Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>$111111.111... (18 bytes)</s> <s>$111999 (17 bytes)</s> $123456 (16 bytes)

Puoi anche rendere il nome della lingua un collegamento, che verrà quindi visualizzato nello snippet della classifica:

# [><>](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>

Modifica: punteggio massimo (arrotondato) massimo per conteggio byte, per un riferimento più rapido - testo qui :

bash, $ 127127

x;echo \$$?$?

Provalo online!

Poiché il xcomando non esiste, si verifica un errore e imposta il codice di uscita su 127.

Quindi, il codice genera un segno di dollaro seguito da $?due volte. La $?variabile memorizza il codice di uscita del comando precedente, quindi questo emette $127127in 13 byte .

Java 8, $ 131.199,00 (15 byte)

v->"$"+'e'*'ԓ'

Provalo online.

Spiegazione:

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$

Ho usato un programma per generare un carattere ASCII stampabile nell'intervallo [32, 126]che, durante la divisione 131199, avrebbe la quantità più bassa di valori decimali. Dal momento che 101può dividere 131199equamente, risultando 1299, sono solo 31 centesimi in meno del mio stipendio massimo possibile in base al mio conteggio dei byte di 15.

CJam , 5 byte, $ 262'144

'$YI#

Provalo online!

Come funziona

'$     Push '$'.
  Y    Push 2.
   I   Push 18.
    #  Pop 2 and 18 and perform exponentiation, pushing 262144.

CJam , (5 byte) $ 294204,018 ...

'$PB#

Provalo online!

Spiegazione:

P$\pi$$\pi^{11} \approx 294000$B

R , 20 byte,$103540.9

T=pi+pi;cat("$",T^T)

Provalo online!

Il massimo per 20 byte è $105737.1, quindi è abbastanza vicino al limite di stipendio!

Sarebbe un bel rilancio, e se venissi pagato per fare il golf del codice ......

GS2 , (5 byte) $ 292.929

•$☺↔A

Un programma completo (mostrato qui usando la code-page 437 ). (Lo stipendio massimo raggiungibile a 5 byte è $ 299069,75)

Provalo online!

Si basa sulla risposta GS2 di Dennis ...

•$☺↔A                             []
•$    - push '$'                  ['$']
  ☺   - push unsigned byte:
   ↔  -   0x1d = 29               ['$',29]
    A - push top of stack twice   ['$',29,29,29]
      - implicit print            $292929

R , 21 byte $ 99649,9

cat("$",min(lynx^pi))

Provalo online!

Un Rapproccio diverso - vedi anche la risposta di Giuseppe

Molto vicino al massimo di $ 101937 per questo byte.

Bonus: object.size()

R , 24 byte $ 89096

cat("$",object.size(ls))

Provalo online!

Questo probabilmente dipende dal sistema, ma quando lo rilancio su TIO ho ottenuto $ 89096 - vicino al limite di 92223 per 24 byte.

JavaScript (ES6), 19 byte, $ 109,839

_=>atob`JDEwOTgzOQ`

Provalo online!

$109839$$\le 109884$

Senza atob()(Node.js), 26 byte, $ 86.126

_=>'$'+Buffer('V~').join``

Provalo online!

La concatenazione di '$' con i codici ASCII di 'V' (86) e '~' (126).

Brainfuck automodificante , 16 byte, $ 124444

<.<++.+.++..../$

Provalo online!

PHP, $ 131116 (8 byte)

Non ne ho visto uno per php e volevo vomitare uno. So che un posto in php è un cattivo typecast che lo taglierebbe a metà ma non riesco a trovarlo in questo momento.

$<?=ERA;

Questo sfrutta solo i tag corti PHP e le costanti incorporate in PHP.

Provalo online!

GS2 , 5 byte, $ 291'000

•$☺↔∟

Questa è una rappresentazione CP437 del codice sorgente binario.

Provalo online!

Come funziona

•$     Push '$'.
  ☺↔   Push 29.
    ∟  Push 1000.

Excel 19 byte $ 107899,616068361

="$"&CODE("(")^PI()

Spiegazione:

     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

Vim, $ 99999 $ 110000 $ 120000

i$=&pvh*&ur

Provalo online!

Utilizza il registro delle espressioni (si noti che esiste un carattere <Cr>, che è invisibile nella maggior parte dei caratteri, tra $e =, per un totale di 13 byte ) per inserire il valore 'pvh'dell'opzione moltiplicato per il valore 'ur'dell'opzione.

'previewheight' è l'opzione che controlla l'altezza delle finestre di anteprima, che è 12 per impostazione predefinita.

'undoreload' è il numero massimo di righe che un buffer può avere prima che vim rinunci a memorizzarlo in memoria per annullarlo, e il suo valore predefinito è 10.000.

Gelatina ,  $ 256000 $ 256256  (6 byte ) $ 257256

⁹‘”$;;

Un programma completo. (Lo stipendio massimo raggiungibile a 6 byte è $ 260847,43)

Provalo online!

Come?

⁹‘”$;; - Main Link: no arguments
⁹      - Literal 256                            256
 ‘     - increment                              257
  ”$   - single '$' character                   '$'
    ;  - concatenate                            ['$',257]
     ; - concatenate                            ['$',257,256]
       - implicit print                      -> $257256

Precedente...

5 byte $ 256256

”$;⁹⁺

('$' concatena 256, ripeti 256 - causando la stampa implicita temporanea)

6 byte $ 256000:

⁹×ȷṭ”$

(256 × 1000 ṭack '$')

C #

Programma completo, 72 byte, $ 40448 66 byte, $ 43008

class P{static void Main()=>System.Console.Write("$"+('T'<<'i'));}

Provalo online!

Spiegazione

L'operatore di spostamento a sinistra tratta i caratteri 'T'e 'i'come interi 84 e 105 rispettivamente ed esegue il turno

Lambda, 19 byte, $ 109568 17 byte, $ 118784

o=>"$"+('t'<<'j')

Provalo online!

Modifica Grazie a @ LegionMammal978 e @Kevin per aver salvato 2 byte

PHP, 13 byte, $ 144000 Stipendio

Sfortunatamente per questo lavoro, è necessario trasferirsi a Mauritius (beh, potrei spostarmi leggermente meno verso est, tuttavia ogni fuso orario in meno produrrebbe un calo di $ 36k di stipendio.) Per compensare l'inconveniente, il mio stipendio aumenta di $ 1 ogni anno bisestile.

$<?=date(ZL);

Questo mette semplicemente Zil fuso orario in pochi secondi e aggiunge se è o meno un anno bisestile.

brainfuck , 43 byte, $ 58888

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

Provalo online!

Come funziona

++++++[>++++++<-]>.  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)

Python 3 , (22 byte) $ 98,442

print('$',ord('𘂊'))

Provalo online!

Proprio come la risposta Ruby di Doorknob , il carattere Unicode a 4 byte qui usato 𘂊, ha un valore ordinale del massimo stipendio intero ottenibile in 22 byte.

Nota che print()stampa i suoi argomenti senza nome separati da spazi di default ( sepè un argomento chiamato opzionale).

Gol> <> , $ 207680 in 8 byte

'o**n; $

Provalo online!

Come funziona:

'        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 $)

È interessante notare che è possibile utilizzare hinvece di n;, che produce 'o**h5$con un punteggio di $ 231504, ma non è possibile utilizzare 0-9 e non esiste un altro modo da 1 byte per spingere 53, il valore ASCII di5

Gelatina , 8 byte, $ 210176.48625619375

⁽½"×½”$,

3535 ( ⁽½") multipli ( ×) ed dal suo sqrt ( ½).

Provalo online!

Mathematica, 18 byte, $ 107.163,49

$~Print~N[E^(E!E)]

Programma completo; corri usando MathematicaScipt -script. Output $107163.4882807548seguiti da una nuova riga finale. Ho verificato che questa è la soluzione più alto punteggio della forma in cui è composto , , , e .$~Print~N[expr]exprPiEI+-* /()!

05AB1E (5 byte), $ 262626

'$₂ÐJ

Provalo online!

$262626 < 299069$$$26$["$", 26, 26, 26]J

JavaScript (Node.js) , 23 byte, $ 65535

_=>"$"+ +(~~[]+`xFFFF`)

Provalo online!

Questo è il meglio che posso ottenere senza atob, anche se c'è un grande spazio di miglioramento tbh

Sai, non avere caratteri corti nella funzione di conversione ASCII fa schifo MOLTO.

DOPO UN INTERO GIORNO

JavaScript (Node.js) , 30 byte, $ 78011

_=>"$"+`𓂻`.codePointAt(![])

Provalo online!

oppure: 29 byte, $ 80020

_=>"$"+`򀀠`.codePointAt(!_)

dove 򀀠si trovaU+13894 INVALID CHARACTER

Oh String.codePointAt! L'ho completamente dimenticato!

Uno scherzo (15 miliardi, $ 130000), non vaild affatto ma solo per divertimento

_=>"$十三萬"

MATLAB, 17 byte, $ 112222

['$','..////'+pi]

Vecchia risposta:

['$','RRUUTR'-'!']

Ruby, $ 119443

$><<?$<<?𝊓.ord

Provalo online!

L'output intero massimo per 17 byte. Il carattere Unicode è U + 1D293, che è 119443 in esadecimale.

dc , $ 169169 10 byte

Dd*d[$]nnn

Provalo online!

Questo stampa 13 ( D) al quadrato, due volte

Japt, 5 byte, $ 262144

'$+I³

Provalo

Spiegazione Iè la costante di Japt 64, la ³cuba e quindi la '$+concatena con il simbolo del dollaro.

Befunge-98 (PyFunge) , 8 byte, $ 209728

$",**.q:

Provalo online!

Il personaggio :è stato calcolato usando il seguente metodo:

>>> chr(int((1_000_000 * 8 ** -0.75) / (ord(' ') * ord('q'))))
':'

Utilizzando @e ffunziona anche ma dà solo $ 208896.

Befunge-93 , 9 byte, $ 192448

a>$",**.@

Provalo online!

Uscite $192448, solo due dollari e nove centesimi in meno del massimo. Funziona anche come un poliglotta con le giuste implementazioni di Befunge-98 , dove non è nemmeno necessario generare un errore di istruzione non riconosciuto!

Spiegazione:

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

Cubix , $ 155088 (12 byte)

*Ouo'ე'$/@

Provalo online!

Un problema interessante, speravo di ottenere questo fino a 7 o 8 byte, ma si è rivelato difficile. Spinge i caratteri ე e $ nello stack, genera il $, moltiplica la parte superiore dello stack, genera il numero e si ferma. Spero ancora di trovare un'opzione byte inferiore