Nota per sfidare gli scrittori secondo il meta consenso : questa domanda è stata ben accolta quando è stata pubblicata, ma è probabile che le sfide come questa, chiedendo ai rispondenti di fare X senza usare Y, siano scarsamente ricevute. Prova a utilizzare la sandbox per ricevere feedback su se desideri pubblicare una sfida simile.

È già il 2017 2018 2019, gente, andate a casa.

Quindi, ora che è il 2014, è tempo di una domanda sul codice che coinvolga il numero 2014.

Il tuo compito è creare un programma che stampa il numero 2014, senza usare nessuno dei caratteri 0123456789nel tuo codice e indipendentemente da qualsiasi variabile esterna come la data o l'ora o un seme casuale.

Vince il codice più breve (conteggio in byte) per farlo in qualsiasi lingua in cui i numeri sono token validi.

Classifica:

var QUESTION_ID=17005,OVERRIDE_USER=7110;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;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-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("{{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 SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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>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>

Mouse-2002 , 4 byte.

Sono 4 byte di ASCII puro e dolce .

Nel mouse , le lettere dell'alfabeto vengono inizializzate ai valori 0-25. !è l'operatore per la stampa di numeri interi, quindi stampa 20quindi 14(nessuna riga nuova intermittente).

U!O!

Non c'è un interprete online disponibile, ma qui troverai un interprete scritto in C (che necessita di alcune modifiche prima di poter forzare gccper compilarlo) e lo stesso interprete compilato per Win32ma che funziona perfettamente su Linux wine.

Qui puoi trovare la versione fissa dell'interprete, che viene compilata.

Python, 52 byte

print sum(ord(c) for c in 'Happy new year to you!')

Aggiornato per il 2015 grazie a @Frg:

print sum(ord(c) for c in 'A Happy New Year to You!')

Passa il mouse sopra per vedere la versione 2016:

print sum(ord(c) for c in 'Happy New Year to you!!!')

Provalo online!

Befunge 98 - 17 11 9 8 byte

'-:*b-.@

Simile alla vecchia versione, ma me ne sono ricordato '

'-:* pushes 45, duplicates it, then squares it, producing 2025
b-   subtracts 11 from it, resulting in 2014
.@   prints the result, then ends the program

È interessante notare che, 45 ² -11 è l'unico abbinamento di numeri a, b, dove Il significato di questi apparecchi è che [32.126] è l'insieme dei caratteri ASCII stampabili e [10,15] è l'insieme dei numeri Befunge facilmente accessibili. Ho trovato quella coppia con questo programma Python :

for a in range(32,127):
    for c in range(10,16):
        if (a**2-c)==2014:
            print("%s,%s"%(a,c))

Oppure, se il tuo interprete supporta Unicode, allora funziona:

Befunge 98-5 byte (4 caratteri)

'ߞ.@

Funziona almeno su http://www.quirkster.com/iano/js/befunge.html con il seguente codice (Befunge 93 - 6 byte / 5 caratteri):

"ߞ".@

Vecchia versione

cdd**e-.@

calcola il numero, quindi lo stampa:

cdd pushes numbers to the stack so that it is this: 12,13,13
**  multiplies top three values of stack, which is now: 2028
e   pushes 14
-   subtracts the top two values of the stack, resulting in: 2014
.   prints the numerical value
@   end of program

Versione precedente:

"*'&("#;:a`j@a+,;

Spinge i valori ASCII per il 2014, -10. Quindi stampa ciascuno dopo aver aggiunto 10 ad esso.

Ruby, 15

p Time.new.year

Temporaneo;)

Si noti che la sezione della domanda

indipendentemente da eventuali variabili esterne come la data o l'ora o un seme casuale

non è stato modificato fino a quando ho pubblicato la mia risposta ...

Jan Dvorak offre un'ottima alternativa nei commenti :

Happy = Time
Happy.new.year

Ma è così poco entusiasta. Preferisco:

Happy = Time
class Time; alias year! year; end

Happy.new.year!

O anche:

class Have; def self.a; A.new; end; end
class A; def happy; Time; end; end
class Time; alias year! year; end

Have.a.happy.new.year!

Ed ecco la punteggiatura inglese corretta:

def noop x = nil; end
alias a noop
alias happy noop
alias new noop
alias year! noop
def Have x
    p Time.new.year
end

Have a happy new year!

Va bene, non ho potuto farne a meno:

def noop x = nil; end
eval %w[we wish you a merry christmas! christmas and a happy new].map{|x|"alias #{x} noop"}*"\n"
def year!; p Time.new.year; end

we wish you a merry christmas! we wish you a merry christmas!
we wish you a merry christmas and a happy new year!

Vai, 2 byte (UTF-16)

Un carattere unicode (2 byte in UTF-16, 3 byte in formato UTF-8), output 2014 come parte di un errore

—

http://ideone.com/dRgKfk

can't load package: package : 
prog.go:1:1: illegal character U+2014 '—'

Python, 26

print int('bbc',ord("\r"))

MATLAB, Scala (4 caratteri, 5 byte)

Qui puoi trarre vantaggio dal sistema di tipo relativamente debole di MATLAB (e di Scala). Il trucco è applicare l' +operazione unaria su una stringa composta solo dal carattere ߞ(del punto di codice UTF-8 U + 07DE, o 2014 in decimale). Questa operazione converte implicitamente la stringa in un doppio (in MATLAB) e in un Int(in Scala):

+'ߞ'

Dettagli di conteggio byte:

• + è ASCII e conta per 1 byte
• ' è ASCII e conta per 1 byte (ma appare due volte nell'espressione)
• ߞ è un carattere UTF-8 a 2 byte

Totale: 5 byte

TeX (32 26 caratteri, altrettanti byte)

\def~{\the\catcode`}~}~\\~\%\bye

Un'alternativa ancora più breve (proposta da Joseph Wright ) è

\number`^^T\number`^^N\bye

XeTeX / LuaTeX (13 caratteri, 14 byte)

Se XeTeX o LuaTeX sono consentiti, l'ingresso UTF-8 può essere utilizzato direttamente (come proposto da Joseph Wright ):

\number`ߞ\bye

dc, 6 caratteri

DiBBCp

• D spinge 13 nello stack, anche se inizialmente la radice di input è 10
• i cambia input radix (a 13 da 10)
• BBC è la base 13 del 2014.
• p stampe.

Uscita console:

$ dc <<< "DiBBCp"
2014

Codice Morse, 23

;)

..--- ----- .---- ....-

72 45 caratteri nel codice; Codici zero caratteri

Questa è tutt'altro che la risposta più breve postata, ma nessuno ha ancora pubblicato una risposta

• non usa i codici carattere come sostituto dei numeri e
• non chiama la data di sistema.

Usando pure math (ok, e una conversione booleana automatica) in R, dalla console R:

x<-(T+T);x+floor(exp(pi)^x)*x*x-(x*x)^(x*x)/x

Stampa il numero 2014. TÈ un sinonimo predefinito true in R. Le funzioni floore expsono direttamente disponibili nel pacchetto base, così come la picostante. R non ha un operatore di incremento, ma la ripetizione (x*x)si è rivelata essere un minor numero di caratteri che fanno incremento e decremento due volte ciascuno.

Versione originale in Javascript (72 caratteri)

Per la semplice ragione che ho potuto provare nella console, e non importa una completa mancanza di spazi bianchi:

m=Math;p=m.pow;t=true;++t+m.floor(p(m.exp(m.PI),t))*t*t++-p(++t,t--)/--t

eseguito nella tua console e stamperà il numero 2014.

Prop a xkcd (e anche ) per farmi pensare a exp (pi):

PS Se puoi ridurre lo stesso algoritmo in una lingua diversa, pubblica un commento con esso.

Scala REPL

34 29 caratteri.

+"Happy new year to you!".sum

Bene ok se lo vuoi davvero giocare a golf con qualsiasi carattere, puoi usare:

'@'*' '-'"'

o

"{yz}"map(_-'I'toChar)

che hanno rispettivamente 11 e 22 caratteri.

PHP, 9 byte

Ciò richiede PHP 7.1 o versioni precedenti. Funzionerà in PHP 7.2, ma genererà un avviso. Nessuna garanzia per qualsiasi versione futura.

xxdnecessario a causa dei dati binari (quindi copiare e incollare sarebbe più facile). Può tornare E_NOTICE, ma non importa, vero?

~ $ xxd -r > 2014.php
0000000: 3c3f 3d7e cdcf cecb 3b                   <?=~....;
~ $ php 2014.php
2014

In alternativa, salvalo utilizzando la codifica ISO-8859-1.

<?=~ÍÏÎË;

C, 33 byte

main(){printf("%d",'A'*' '-'B');}

Mathematica, 14 caratteri (o 15 se conti la bitmap come carattere)

TextRecognize @

Python3.4.0b2 (0 byte)

% python3.4  
Python 3.4.0b2 (v3.4.0b2:ba32913eb13e, Jan  5 2014, 11:02:52) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 

Javascript, 23 byte

Utilizza la conversione di base 64

alert(atob("MjAxNA=="))

23 caratteri (16 con atob da solo)

O

alert("MMXIV") // ;)

Perl - 10 caratteri

Questa soluzione è stata gentilmente concessa da BrowserUK su PerlMonks , anche se ho eliminato alcuni segni di punteggiatura e spazi bianchi non necessari dalla soluzione che ha pubblicato. È un "non" bit a bit su una stringa binaria di quattro caratteri.

say~"ÍÏÎË"

I caratteri visualizzati sopra rappresentano gli ottetti binari cd: cf: ce: cb e sono come appaiono in ISO-8859-1 e ISO-8859-15.

Ecco l'intero script in esadecimale, più un esempio eseguendolo:

$ hexcat ~/tmp/ten-stroke.pl
73:61:79:7e:22:cd:cf:ce:cb:22
$ perl -M5.010 ~/tmp/ten-stroke.pl
2014

Perl (senza bit alti) - 14 caratteri

say'````'^RPQT

Questo utilizza un bit a bit "o" sulle due stringhe di quattro caratteri "RPQT"e "````"(cioè quattro backtick).

$ ~/tmp/fourteen-stroke.pl
73:61:79:27:60:60:60:60:27:5e:52:50:51:54
$ perl -M5.010 ~/tmp/fourteen-stroke.pl
2014

(Inizialmente avevo le due stringhe al contrario, il che richiedeva spazi bianchi tra printe RPQTper separare i token. @DomHastings ha sottolineato che cambiandoli potevo salvare un personaggio.)

Perl (barare) - 8 caratteri

Questo probabilmente non rientra nello spirito della competizione, ma hdb su PerlMonks ha sottolineato che Perl fornisce una variabile chiamata $0che contiene il nome del programma corrente in esecuzione. Se ci è permesso di nominare il file contenente lo script "2014", allora $0sarà uguale a 2014. $0contiene una cifra, quindi non possiamo usarlo direttamente, ma ${...}contenere un'espressione che valuta 0 sarà OK; per esempio:

say${$|}

Per coerenza, facciamo la cosa hexcat-then-perl con quella:

$ hexcat 2014
73:61:79:24:7b:24:7c:7d
$ perl -M5.010 2014
2014

Penso che questo sia un imbroglio, ma è comunque una soluzione interessante, quindi vale la pena menzionarlo.

Ruby, 20 anni

p 'bbc'.to_i ?\r.ord

Spiegazione: bbcè 2014nella base 13. Più corta di Python. Non basso come Forth.

Powershell, 9

+"ߞ"[""]

ߞ( U + 07DE NKO LETTER KA ) viene conteggiato come due byte in base alle informazioni del tag golf-code .

[""]restituisce il primo carattere dalla stringa ( ""viene convertito in 0). Unary plus opeartor ( +) converte il carattere in un numero intero.

Scala REPL - 6 caratteri

"?="##

( ##è il simbolo di Scala che significa hashCode, e la stringa Java ha "?="hash al 2014.)

Scala REPL - 4 caratteri, 5 byte

+'ߞ'

La matematica sul nostro personaggio Unicode preferito produce un Int.

Javascript, 18 caratteri

alert(btoa('ÛMx'))

Aggiornamento: in ES6, l'utilizzo di un modello letterale può salvare due caratteri:

alert(btoa`ÛMx`)

Il codice sopra è abbastanza facile da capire tenendo presente che btoaconverte una stringa in un'altra stringa in base a una serie di regole ben definite ( RFC 4648 ). Per vedere come funziona la conversione, scriveremo la stringa di input "ÛMx" come una sequenza di cifre binarie, in cui ogni carattere viene visualizzato come codice carattere a 8 bit.

Carattere di input | Û | M | X
Codice carattere (decimale) | 219 | 77 | 120
Codice carattere (binario) | 11011011 | 01001101 | 01111000

Dopo aver riorganizzato le cifre binarie nell'ultima riga in gruppi di 6, otteniamo la rappresentazione binaria di 4 nuovi numeri, corrispondenti agli indici Base64 dei 4 caratteri nella stringa "2014".

Indice Base64 (binario) | 110110 | 110100 | 110101 | 111000
Indice Base64 (decimale) | 54 | 52 | 53 | 56
Carattere di output | 2 | 0 | 1 | 4

Secondo le specifiche HTML, i caratteri di output possono essere recuperati dai loro indici Base64 secondo questa tabella: http://dev.w3.org/html5/spec-LC/webappapis.html#base64-table .

Se non ti interessano i dettagli, potresti lasciare che il browser esegua i calcoli per te e scoprire che "ÛMx" è il risultato della valutazione atob('2014')in Javascript.

Ancora un'altra voce GolfScript, 9 caratteri stampabili

Credo che questo sia più breve di qualsiasi voce GolfScript stampabile finora:

"!="{*}*)

( La voce di 7 caratteri di Peter Taylor lo batte, ma include caratteri di controllo non stampabili.)

Io chiamo questo "è così l'anno scorso!" voce, perché ciò che effettivamente fa è generare il numero 2013 in 8 caratteri, come 33 × 61, e quindi lo incrementa di uno. ;-)

C (31)

main(){printf("%o",' b'/'\b');}

C (32)

main(){printf("%x%o",' ','\f');}

C (30)

main(){printf("%x",' j'^'~');}

C (30)

main(){printf("%d",'\a\xde');}

Avanti, 14

'> '" * '^ - .      

GolfScript, 14

'-+,/'{)))))}%

Come funziona: ASCII va così:

...
+
,
-
.
/
0
1
2
3
4
...

Quindi, questo prende i codici ASCII di ogni carattere, ne sottrae cinque e lo inserisce in una stringa.

{...}%restituisce una matrice dei caratteri di una stringa mappata, quando viene fornita una stringa come argomento. Quindi, incrementa ogni carattere di 5 ( )significa incremento).

Python, 32 caratteri

print ord(',')*ord('-')+ord('"')

Probabilmente è possibile ridurlo usando il char Unicode del 2014 ߞ, ma non ci ho provato.

Quincunx lo nota

a=ord('.');print a*a-ord('f')

è più corto di tre caratteri.

APL (6 byte, 4 caratteri)

⊃⎕TS

Funziona solo quest'anno però.

Perché funziona:

      ⎕TS
2014 1 1 11 58 5 811
      ⊃⎕TS
2014

Senza fare affidamento sulla data di sistema, è di 10 byte (7 caratteri):

⎕UCS'ߞ'

Python 32 10 byte, 91 85 (66 mathimportati per impostazione predefinita) byte matematica pura

Mi sono divertito a scrivere questo:

my_lst = []
for i in range(33, 126):
    for j in range(i, 126):
        if 2014 - 126 < i * j < 2014 - 33:
            if j not in range(48, 58):
                my_lst.append("ord('" + unichr(i) +
                              "')*ord('" + unichr(j) +
                              "')+ord('" + unichr(2014 - i * j) + "')")

for val in my_lst:
    print val, '->', eval(val)

Stampa tutti i modi possibili che posso scrivere 2014usando il metodo di Bruno Le Floch (32 caratteri):

ord('!')*ord(':')+ord('d') -> 2014
ord('!')*ord(';')+ord('C') -> 2014
ord('!')*ord('<')+ord('"') -> 2014
ord('"')*ord(':')+ord('*') -> 2014
ord(')')*ord('/')+ord('W') -> 2014
ord('*')*ord('-')+ord('|') -> 2014
ord('*')*ord('.')+ord('R') -> 2014
ord('*')*ord('/')+ord('(') -> 2014
ord('+')*ord(',')+ord('z') -> 2014
ord('+')*ord('-')+ord('O') -> 2014
ord('+')*ord('.')+ord('$') -> 2014
ord(',')*ord(',')+ord('N') -> 2014
ord(',')*ord('-')+ord('"') -> 2014

Ma questo è ovviamente ridondante, quindi se il tuo interprete è impostato su utf-8 di default, allora tutto ciò che serve è:

>>> ord(u'ߞ')
2014

Inoltre, grazie ad AmeliaBR (per l'idea), ho fatto del mio meglio per implementare una versione matematica pura:

from math import*
a,b,c=int(e),round(e),ceil(pi);print int(a**(b*c-(c-b))-a*a**c-a)

R (20 caratteri)

@popojan (non è ancora autorizzato a pubblicare una risposta qui) ha fornito la soluzione entro 20 caratteri.

sum(T+T:exp(T+pi))-T

Produzione:

> sum(T+T:exp(T+pi))-T
[1] 2014

R (22 caratteri)

L'utente anonimo ha suggerito una soluzione più breve.

strtoi("bbc",pi*pi+pi)

2014è BBCin base 13. pi*pi+pi(= 13.0112) è trattato da R in questo contesto come intero 13. Output:

> strtoi("bbc",pi*pi+pi)
2014

R (30 caratteri)

Grazie a @Tomas!

cat(a<-T+T,T-T,T/T,a*a,sep="")

Produzione:

> cat(a<-T+T,T-T,T/T,a*a,sep="")
2014

R (31 caratteri)

cat(T+T,T-T,T/T,T+T+T+T,sep="")

Ispirato dalla risposta di AmeliaBR . Produzione:

> cat(T+T,T-T,T/T,T+T+T+T,sep="")
2014

Java - 77 75 caratteri

75 caratteri se printviene aggiunto in una classe con il metodo principale:

class C{public static void main(String[]a){System.out.print('#'*'<'-'V');}}

Significa 35*60-86che è uguale al 2014