Hinweis zum Herausfordern von Autoren gemäß Metakonsens : Diese Frage wurde zum Zeitpunkt der Veröffentlichung gut aufgenommen, aber Herausforderungen wie diese, bei denen die Beantworter zu X aufgefordert werden, ohne Y zu verwenden, werden wahrscheinlich schlecht aufgenommen. Verwenden Sie die Sandbox , um Feedback zu erhalten, ob Sie eine ähnliche Herausforderung veröffentlichen möchten.

Es ist schon 2017, 2018, 2019, Leute, geht nach Hause.

Jetzt, da es 2014 ist, ist es Zeit für eine Code-Frage mit der Nummer 2014.

Ihre Aufgabe ist es, ein Programm zu erstellen, das die Zahl druckt 2014, ohne die Zeichen 0123456789in Ihrem Code zu verwenden und unabhängig von externen Variablen wie Datum oder Uhrzeit oder einem zufälligen Startwert.

Der kürzeste Code (in Bytes), der in einer Sprache verwendet wird, in der Zahlen gültige Token sind, gewinnt.

Bestenliste:

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 Bytes.

Das sind 4 Bytes reines, süßes ASCII.

In der Maus werden die Buchstaben des Alphabets mit den Werten 0-25 initialisiert. !ist der Operator zum Drucken von ganzen Zahlen, daher wird dieser 20dann gedruckt 14(keine intermittierende Newline).

U!O!

Es gibt keinen Online-Interpreter, aber hier finden Sie einen in C geschriebenen Interpreter (der einige Anpassungen benötigt, bevor gccer kompiliert werden kann) und denselben kompilierten Interpreter Win32, der jedoch unter Linux einwandfrei funktioniert wine.

Hier finden Sie die feste Version des Interpreters, der kompiliert.

Python, 52 Bytes

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

Aktualisiert für 2015 dank @Frg:

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

Fahren Sie mit der Maus über die Version 2016:

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

Probieren Sie es online!

Befunge 98 - 17 11 9 8 Bytes

'-:*b-.@

Ähnlich wie die alte Version, aber ich erinnerte mich an '

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

Interessanterweise ist 45 ² -11 die einzige Paarung von Zahlen a, b, wobei Die Bedeutung dieser Mengen ist, dass [32,126 ] ist die Menge der druckbaren ASCII-Zeichen und [10,15] die Menge der leicht zugänglichen Befunge-Zahlen. Ich habe dieses Paar mit diesem Python-Programm gefunden :

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

Wenn Ihr Interpreter Unicode unterstützt, funktioniert Folgendes:

Befunge 98 - 5 Bytes (4 Zeichen)

'ߞ.@

Es funktioniert zumindest unter http://www.quirkster.com/iano/js/befunge.html mit dem folgenden Code (Befunge 93 - 6 Byte / 5 Zeichen):

"ߞ".@

Alte Version

cdd**e-.@

berechnet die Zahl und gibt sie aus:

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

Ältere Version:

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

Pusht die ASCII-Werte für 2014, -10. Anschließend wird jeweils nach dem Hinzufügen von 10 gedruckt.

Rubin, 15

p Time.new.year

Befristet;)

Beachten Sie, dass der Abschnitt der Frage

unabhängig von externen Variablen wie Datum oder Uhrzeit oder einem zufälligen Startwert

wurde erst bearbeitet, nachdem ich meine Antwort gepostet hatte ...

Jan Dvorak bietet eine großartige Alternative in den Kommentaren :

Happy = Time
Happy.new.year

Aber es ist so wenig begeistert. Ich bevorzuge:

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

Happy.new.year!

Oder auch:

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!

Und hier ist die korrekte englische Interpunktion:

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!

Okay, okay, ich konnte nicht anders:

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!

Go, 2 Bytes (UTF-16)

Ein Unicode-Zeichen (2 Byte in UTF-16, 3 Byte in UTF-8), Ausgabe 2014 als Teil eines Fehlers

—

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 Zeichen, 5 Bytes)

Hier können Sie das relativ schwache Typensystem von MATLAB (und Scala) ausnutzen. Der Trick besteht darin, die unäre +Operation auf eine Zeichenfolge anzuwenden, die nur aus dem Zeichen besteht ߞ(UTF-8-Codepunkt U + 07DE oder 2014 in Dezimalzahl). Diese Operation konvertiert den String implizit in ein Double (in MATLAB) und in ein Int(in Scala):

+'ߞ'

Byte-Count-Details:

• + ist ASCII und zählt für 1 Byte
• ' ist ASCII und zählt für 1 Byte (erscheint aber zweimal im Ausdruck)
• ߞ ist ein 2-Byte-UTF-8-Zeichen

Gesamt: 5 Bytes

TeX (32 26 Zeichen (beliebig viele Bytes)

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

Eine noch kürzere Alternative (vorgeschlagen von Joseph Wright ) ist

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

XeTeX / LuaTeX (13 Zeichen, 14 Bytes)

Wenn XeTeX oder LuaTeX zulässig sind, kann die UTF-8-Eingabe direkt verwendet werden (wie von Joseph Wright vorgeschlagen ):

\number`ߞ\bye

Gleichstrom, 6 Zeichen

DiBBCp

• D drückt 13 auf den Stack, obwohl der Eingangsradix anfangs 10 ist
• i Ändert den Eingaberadix (auf 13 von 10)
• BBC ist 2014 Basis 13.
• p druckt.

Konsolenausgabe:

$ dc <<< "DiBBCp"
2014

Morsecode, 23

;)

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

72 45 Zeichen im Code; Nullzeichencodes

Dies ist bei weitem nicht die kürzeste Antwort, aber bisher hat noch niemand eine Antwort veröffentlicht

• verwendet keine Zeichencodes als Ersatz für Zahlen und
• ruft das Systemdatum nicht auf.

Verwenden von reiner Mathematik (okay, und einer automatischen Booleschen Konvertierung) in R über die R-Konsole:

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

Gibt die Zahl 2014 aus. Ist Tein vordefiniertes Synonym für wahr in R. Die Funktionen floorund expsind ebenso wie die piKonstante direkt im Basispaket verfügbar . R hat keinen Inkrementierungsoperator, wiederholt (x*x)jedoch weniger Zeichen, die zweimal inkrementiert und dekrementiert werden.

Originalversion in Javascript (72 Zeichen)

Aus dem einfachen Grund, dass ich in der Konsole testen konnte und es nichts ausmacht, wenn Whitespace fehlt:

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

Führen Sie in Ihrer Konsole aus, und es wird die Nummer 2014 zurück gedruckt.

Requisiten an xkcd (und auch ), damit ich über exp (pi) nachdenke:

PS Wenn Sie denselben Algorithmus in einer anderen Sprache kürzer machen können, fügen Sie ihm einen Kommentar hinzu.

Scala REPL

34 29 Zeichen.

+"Happy new year to you!".sum

Na gut, wenn Sie wirklich wollen, dass es mit irgendwelchen Zeichen gespielt wird, können Sie Folgendes verwenden:

'@'*' '-'"'

oder

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

die jeweils 11 und 22 Zeichen haben.

PHP, 9 Bytes

Dies erfordert PHP 7.1 oder niedriger. Es wird in PHP 7.2 funktionieren, aber es wird eine Warnung auslösen. Keine Garantie für zukünftige Versionen.

xxdwird aufgrund von Binärdaten benötigt (daher ist das Kopieren und Einfügen einfacher). Kann zurückkehren E_NOTICE, aber es spielt keine Rolle, oder?

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

Alternativ können Sie dies mit der ISO-8859-1-Codierung speichern.

<?=~ÍÏÎË;

C 33 Bytes

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

Mathematica, 14 Zeichen (oder 15, wenn Sie die Bitmap als Zeichen zählen)

TextRecognize @

Python3.4.0b2 (0 Bytes)

% 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 Bytes

Verwendet die Base 64-Konvertierung

alert(atob("MjAxNA=="))

23 Zeichen (16 mit atob alleine)

Oder

alert("MMXIV") // ;)

Perl - 10 Zeichen

Diese Lösung wurde mit freundlicher Genehmigung von BrowserUK auf PerlMonks erstellt , obwohl ich einige unnötige Satzzeichen und Leerzeichen von der von ihm veröffentlichten Lösung entfernt habe. Es ist ein bitweises "Nicht" für eine vierstellige Binärzeichenfolge.

say~"ÍÏÎË"

Die oben angezeigten Zeichen stellen die binären Oktette cd: cf: ce: cb dar und entsprechen der Darstellung in ISO-8859-1 und ISO-8859-15.

Hier ist das gesamte Skript in hexadezimaler Schreibweise sowie ein Beispiel, in dem es ausgeführt wird:

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

Perl (ohne hohe Bits) - 14 Zeichen

say'````'^RPQT

Dies verwendet ein bitweises "oder" für die beiden Zeichenfolgen mit vier Zeichen "RPQT"und "````"(dh vier Backticks).

$ ~/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

(Anfangs hatte ich die beiden Zeichenfolgen umgekehrt, was Leerzeichen zwischen printund RPQTzum Trennen der Token erforderte . @DomHastings wies darauf hin, dass ich ein Zeichen speichern könnte, indem ich sie vertauschte.)

Perl (Schummeln) - 8 Zeichen

Dies ist wahrscheinlich nicht im Sinne des Wettbewerbs, aber hdb auf PerlMonks hat darauf hingewiesen, dass Perl eine Variable namens $0enthält, die den Namen des aktuell ausgeführten Programms enthält. Wenn wir die Datei mit dem Skript "2014" benennen dürfen, ist $0sie gleich 2014. Sie $0enthält eine Ziffer, daher können wir sie nicht direkt verwenden, aber wenn ${...}ein Ausdruck mit 0 ausgewertet wird, ist dies in Ordnung. zum Beispiel:

say${$|}

Lassen Sie uns der Konsistenz halber das Hexcat-dann-Perl-Ding damit machen:

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

Ich denke, das ist Betrug, aber es ist trotzdem eine interessante Lösung, die es wert ist, erwähnt zu werden.

Rubin, 20

p 'bbc'.to_i ?\r.ord

Erläuterung: bbcbefindet sich 2014in Basis 13. Kürzer als Python. Nicht so kurz wie Forth.

Powershell, 9

+"ߞ"[""]

ߞ( U + 07DE NKO LETTER KA ) wird gemäß der Code-Golf-Tag-Information als zwei Bytes gezählt .

[""]Gibt das erste Zeichen der Zeichenfolge zurück ( ""wird konvertiert in 0). Der unary plus opeartor ( +) konvertiert das Zeichen in eine Ganzzahl.

Scala REPL - 6 Zeichen

"?="##

( ##Ist die Symbolbedeutung von Scala hashCodeund der Java-String entspricht "?="2014.)

Scala REPL - 4 Zeichen, 5 Bytes

+'ߞ'

Mathe auf unserem Lieblings-Unicode-Charakter ergibt eine Int.

Javascript, 18 Zeichen

alert(btoa('ÛMx'))

Update: In ES6 können mit einem Vorlagenliteral zwei Zeichen gespeichert werden:

alert(btoa`ÛMx`)

Der obige Code ist recht einfach zu verstehen, wenn man bedenkt, dass btoaeine Zeichenfolge gemäß einer Reihe gut definierter Regeln ( RFC 4648 ) in eine andere Zeichenfolge konvertiert wird . Um zu sehen, wie die Konvertierung funktioniert, schreiben wir die Eingabezeichenfolge "ÛMx" als Folge von Binärziffern, wobei jedes Zeichen als 8-Bit-Zeichencode dargestellt wird.

Eingabezeichen | Û | M | X
Zeichencode (dezimal) | 219 | 77 | 120
Zeichencode (binär) | 11011011 | 01001101 | 01111000

Nach der Reorganisation der Binärziffern in der letzten Zeile in 6er-Gruppen erhalten wir die Binärdarstellung von 4 neuen Zahlen, die den Base64-Indizes der 4 Zeichen in der Zeichenfolge "2014" entsprechen.

Base64-Index (binär) | 110110 | 110100 | 110101 | 111000
Base64-Index (dezimal) | 54 | 52 | 53 | 56
Ausgabezeichen | 2 | 0 | 1 | 4

Gemäß der HTML-Spezifikation können die Ausgabezeichen anhand der folgenden Tabelle aus ihren Base64-Indizes abgerufen werden: http://dev.w3.org/html5/spec-LC/webappapis.html#base64-table .

Wenn Sie sich nicht um die Details kümmern, können Sie den Browser die Berechnungen für Sie durchführen lassen und feststellen, dass "ÛMx" das Ergebnis der Auswertung atob('2014')in Javascript ist.

Noch ein GolfScript-Eintrag, 9 druckbare Zeichen

Ich glaube, das ist kürzer als alle druckbaren GolfScript-Einträge:

"!="{*}*)

( Peter Taylors 7- Zeichen -Eintrag schlägt es, enthält aber nicht druckbare Steuerzeichen.)

Ich nenne das das "das ist so letztes Jahr!" Eintrag, denn was es tatsächlich tut, ist die Zahl 2013 in 8 Zeichen, als 33 × 61, zu generieren und dann um eins zu erhöhen. ;-)

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');}

Viertens, 14

'> '" * '^ - .      

GolfScript, 14

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

So funktioniert es: ASCII geht so:

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

Dies nimmt also die ASCII-Codes jedes Zeichens, subtrahiert fünf und fügt sie in eine Zeichenfolge ein.

{...}%Gibt ein Array der Zeichen einer Zeichenfolge zurück, die zugeordnet sind, wenn eine Zeichenfolge als Argument angegeben wird. So erhöht es jedes Zeichen um 5 ( )bedeutet Inkrement).

Python, 32 Zeichen

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

Wahrscheinlich ist es möglich, es mit dem 2014. Unicode-Zeichen zu reduzieren ߞ, aber ich habe es nicht versucht.

Quincunx merkt das an

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

ist um drei Zeichen kürzer.

APL (6 Bytes, 4 Zeichen)

⊃⎕TS

Funktioniert allerdings nur in diesem Jahr.

Warum es funktioniert:

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

Ohne auf das Systemdatum angewiesen zu sein, sind es 10 Bytes (7 Zeichen):

⎕UCS'ߞ'

Python 32 10 Bytes, 91 85 (66 mit mathstandardmäßig importierten) Bytes reine Mathematik

Hatte ein bisschen Spaß beim Schreiben:

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)

Druckt alle möglichen Schreibweisen 2014nach Bruno Le Floch (32 Zeichen):

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

Dies ist jedoch offensichtlich redundant. Wenn Ihr Interpreter also standardmäßig auf utf-8 eingestellt ist, ist Folgendes erforderlich:

>>> ord(u'ߞ')
2014

Dank AmeliaBR (für die Idee) habe ich mein Bestes gegeben, um eine reine Mathematikversion zu implementieren:

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 Zeichen)

@popojan (er darf hier noch keine Antwort schreiben) hat die Lösung innerhalb von 20 Zeichen bereitgestellt.

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

Ausgabe:

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

R (22 Zeichen)

Anonymer Benutzer hat kürzere Lösung vorgeschlagen.

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

2014ist BBCin der Basis 13. pi*pi+pi(= 13.0112) wird in diesem Zusammenhang von R als ganze Zahl 13 behandelt.

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

R (30 Zeichen)

Vielen Dank an @Tomas!

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

Ausgabe:

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

R (31 Zeichen)

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

Inspiriert von der Antwort von AmeliaBR . Ausgabe:

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

Java - 77 75 Zeichen

75 Zeichen, wenn printin einer Klasse mit der Hauptmethode hinzugefügt wird:

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

Das heißt, 35*60-86das ist gleich 2014