Note pour défier les rédacteurs selon une méta-consensus : cette question a été bien accueillie lorsqu'elle a été postée, mais les défis de ce type, demander aux personnes qui répondent à Do X sans utiliser Y risquent d'être mal accueillis. Essayez d’utiliser le bac à sable pour obtenir des commentaires si vous souhaitez publier un défi similaire.

Nous sommes en 2017 2018 2019, rentrez chez vous.

Donc, maintenant que nous sommes en 2014, il est temps de poser une question sur le code portant le numéro 2014.

Votre tâche consiste à créer un programme qui imprime le nombre 2014, sans utiliser aucun des caractères 0123456789de votre code, et indépendamment de toute variable externe telle que la date ou l'heure ou une graine aléatoire.

Le code le plus court (comptant en octets) pour le faire, quelle que soit la langue dans laquelle les nombres sont valides, gagne le jeton.

Classement:

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>

Souris-2002 , 4 octets.

C'est 4 octets d' ASCII pur et doux .

Dans Mouse , les lettres de l'alphabet sont initialisées aux valeurs 0-25. !est l'opérateur pour l'impression des entiers, donc ceci est 20ensuite imprimé 14(pas de nouvelle ligne intermittente).

U!O!

Il n'y a pas d' interprète disponible en ligne, mais ici vous trouverez un interprète écrit en C (nécessitant quelques modifications avant que l' on peut forcer gccà le compiler) et le même interpréteur compilé pour Win32mais qui fonctionne parfaitement sous Linux avec wine.

Ici vous pouvez trouver la version corrigée de l'interpréteur, qui compile.

Python, 52 octets

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

Mis à jour pour 2015 grâce à @Frg:

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

Passez la souris sur la version 2016:

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

Essayez-le en ligne!

Befunge 98 - 17 11 9 8 octets

'-:*b-.@

Semblable à l'ancienne version, mais je me souvenais de '

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

Il est intéressant de 45 ² -11 est le couplage seulement des nombres a, b , où La signification de ces ensembles est que [32126] est l'ensemble des caractères imprimables ascii et [10,15] est l'ensemble des nombres Befunge facilement accessibles. J'ai trouvé cette paire avec ce programme python :

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

Ou, si votre interprète prend en charge l'unicode, cela fonctionne:

Befunge 98 - 5 octets (4 caractères)

'ߞ.@

Cela fonctionne au moins sur http://www.quirkster.com/iano/js/befunge.html avec le code suivant (Befunge 93 - 6 octets / 5 caractères):

"ߞ".@

Ancienne version

cdd**e-.@

calcule le nombre puis l’imprime:

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

Ancienne version:

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

Pousse les valeurs ascii pour 2014, -10. Puis imprime chacun après avoir ajouté 10.

Ruby, 15 ans

p Time.new.year

Temporaire;)

Notez que la section de la question

indépendamment de toute variable externe telle que la date ou l'heure ou une graine aléatoire

n’a été modifié que longtemps après que j’ai posté ma réponse ...

Jan Dvorak offre une excellente alternative dans les commentaires :

Happy = Time
Happy.new.year

Mais c'est tellement peu enthousiaste. Je préfère:

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

Happy.new.year!

Ou même:

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!

Et voici la ponctuation anglaise correcte:

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!

D'accord, d'accord, je ne pouvais pas m'en empêcher:

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 octets (UTF-16)

Un caractère Unicode (2 octets en UTF-16, 3 octets en format UTF-8), sortie 2014 dans le cadre d'une erreur

—

http://ideone.com/dRgKfk

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

Python, 26 ans

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

MATLAB, Scala (4 caractères, 5 octets)

Vous pouvez tirer parti du système de types relativement faible de MATLAB (et de Scala), ici. L'astuce consiste à appliquer l' +opération unaire sur une chaîne composée uniquement du caractère ߞ(du point de code UTF-8 U + 07DE ou 2014 en décimal). Cette opération convertit implicitement la chaîne en un double (en MATLAB) et en un Int(en Scala):

+'ߞ'

Nombre d'octets:

• + est ASCII et compte pour 1 octet
• ' est ASCII et compte pour 1 octet (mais apparaît deux fois dans l'expression)
• ߞ est un caractère UTF-8 à 2 octets

Total: 5 octets

TeX (32 26 caractères, autant d'octets)

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

Une alternative encore plus courte (proposée par Joseph Wright ) est

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

XeTeX / LuaTeX (13 caractères, 14 octets)

Si XeTeX ou LuaTeX sont autorisés, l'entrée UTF-8 peut être utilisée directement (comme proposé par Joseph Wright ):

\number`ߞ\bye

dc, 6 caractères

DiBBCp

• D pousse 13 sur la pile, même si la base d'entrée est 10 initialement
• i change la base d'entrée (de 13 à 13)
• BBC est 2014 base 13.
• p impressions.

Sortie de la console:

$ dc <<< "DiBBCp"
2014

Code morse, 23

;)

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

72 45 caractères dans le code; Codes de caractère zéro

C’est loin d’être la réponse la plus courte publiée, mais personne n’a encore posté de réponse

• n'utilise pas de codes de caractères pour remplacer des chiffres, et
• n'appelle pas la date du système.

Utilisation de mathématiques pures (d'accord, et d'une conversion booléenne automatique) sous R, à partir de la console R:

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

Imprime le nombre 2014. Test un synonyme prédéfini pour true dans R. Les fonctions flooret expsont directement disponibles dans le package de base, tout comme la piconstante. R n'a pas d'opérateur d'incrémentation, mais il est répété (x*x)qu'il y a moins de caractères qui incrémentent et décrémentent deux fois chacun.

Version originale en Javascript (72 caractères)

Pour la simple raison que j'ai pu tester sur la console et que l'absence totale d'espace est un inconvénient:

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

exécutez dans votre console et il imprimera le numéro 2014.

Des accessoires à xkcd (et aussi ) pour m'avoir fait penser à exp (pi):

PS Si vous pouvez raccourcir le même algorithme dans une langue différente, postez un commentaire avec celui-ci.

Scala REPL

34 29 caractères.

+"Happy new year to you!".sum

Bien ok si vous voulez vraiment jouer avec des personnages, vous pouvez utiliser:

'@'*' '-'"'

ou

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

qui ont respectivement 11 et 22 caractères.

PHP, 9 octets

Cela nécessite PHP 7.1 ou inférieur. Cela fonctionnera sous PHP 7.2, mais cela entraînera un avertissement. Aucune garantie pour les versions futures.

xxdnécessaires en raison de données binaires (il serait donc plus facile de copier et coller). Peut revenir E_NOTICE, mais cela n'a pas vraiment d'importance, n'est-ce pas?

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

Sinon, enregistrez ceci en utilisant le codage ISO-8859-1.

<?=~ÍÏÎË;

C, 33 octets

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

Mathematica, 14 caractères (ou 15 si vous comptez le bitmap comme un caractère)

TextRecognize @

Python3.4.0b2 (0 octet)

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

Utilise la conversion en base 64

alert(atob("MjAxNA=="))

23 caractères (16 avec atob seul)

Ou

alert("MMXIV") // ;)

Perl - 10 caractères

Cette solution est une gracieuseté de BrowserUK sur PerlMonks , bien que je me sois débarrassé de la ponctuation et des espaces inutiles de la solution qu'il a publiée. C'est un bitwise "pas" sur une chaîne binaire de quatre caractères.

say~"ÍÏÎË"

Les caractères affichés ci-dessus représentent les octets binaires cd: cf: ce: cb, et indiquent comment ils apparaissent dans ISO-8859-1 et ISO-8859-15.

Voici l'intégralité du script au format hexadécimal, ainsi qu'un exemple d'exécution:

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

Perl (sans bits forts) - 14 caractères

say'````'^RPQT

Ceci utilise un "ou" au niveau des bits sur les deux chaînes de quatre caractères "RPQT"et "````"(c'est-à-dire quatre 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

(Au départ, j'avais les deux chaînes inversées , ce qui nécessitait des espaces blancs printet RPQTséparant les jetons. @DomHastings a fait remarquer qu'en les changeant, je pouvais enregistrer un personnage.)

Perl (tricherie) - 8 caractères

Cela n’est probablement pas dans l’esprit de la concurrence, mais hdb sur PerlMonks a fait remarquer que Perl fournit une variable appelée $0contenant le nom du programme en cours d’exécution. Si nous sommes autorisés à nommer le fichier contenant le script "2014", il $0sera égal à 2014. $0contient un chiffre; nous ne pouvons donc pas l'utiliser directement, mais ${...}contenir une expression dont le résultat est 0 sera OK; par exemple:

say${$|}

Par souci de cohérence, faisons la chose hexcat-then-perl avec ça:

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

Je pense que c'est de la triche, mais c'est quand même une solution intéressante, donc il vaut la peine d'être mentionné.

Ruby, 20 ans

p 'bbc'.to_i ?\r.ord

Explication: bbcest 2014en base 13. Plus court que Python. Pas aussi court que Forth.

Powershell, 9

+"ߞ"[""]

ߞ( U + 07DE NKO LETTER KA ) est compté comme deux octets selon les informations de balise code-golf .

[""]renvoie le premier caractère de la chaîne ( ""est converti en 0). Le unary plus opeartor ( +) convertit le caractère en entier.

Scala REPL - 6 caractères

"?="##

( ##est le symbole de Scala hashCode, et la chaîne Java"?=" hache jusqu'en 2014.)

Scala REPL - 4 caractères, 5 octets

+'ߞ'

Math sur notre personnage préféré unicode produit un Int.

Javascript, 18 caractères

alert(btoa('ÛMx'))

Mise à jour: dans ES6, l'utilisation d'un littéral de modèle peut enregistrer deux caractères:

alert(btoa`ÛMx`)

Le code ci-dessus est assez facile à comprendre en gardant à l’esprit que btoa la chaîne est convertie en une autre chaîne selon un ensemble de règles bien définies ( RFC 4648). ). Pour voir comment la conversion fonctionne, nous allons écrire la chaîne d'entrée "ÛMx" sous la forme d'une séquence de chiffres binaires, où chaque caractère est rendu sous la forme d'un code de caractère à 8 bits.

Caractère d'entrée | Û | M | X
Code de caractère (décimal) | 219 | 77 | 120
Code de caractère (binaire) | 11011011 | 01001101 | 01111000

Après avoir réorganisé les chiffres binaires de la dernière ligne en groupes de 6, nous obtenons la représentation binaire de 4 nouveaux nombres, correspondant aux index Base64 des 4 caractères de la chaîne "2014".

Index Base64 (binaire) | 110110 | 110100 | 110101 | 111000
Index Base64 (décimal) | 54 | 52 | 53 | 56
Caractère de sortie | 2 | 0 | 1 | 4

Selon la spécification HTML, les caractères de sortie peuvent être extraits de leurs index Base64 conformément à ce tableau: http://dev.w3.org/html5/spec-LC/webappapis.html#base64-table .

Si vous ne vous souciez pas des détails, vous pouvez laisser le navigateur faire les calculs pour vous et découvrir que "ÛMx" est le résultat d'une évaluation atob('2014')en Javascript.

Encore une autre entrée GolfScript, 9 caractères imprimables

Je pense que cela est plus court que toutes les entrées imprimables de GolfScript jusqu'à présent:

"!="{*}*)

( L'entrée à 7 caractères de Peter Taylor le bat, mais comprend des caractères de contrôle non imprimables.)

J'appelle cela le "c'est tellement l'année dernière!" car elle génère le nombre 2013 en 8 caractères, comme 33 × 61, puis l’incrémente d’un chiffre . ;-)

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

14ème

'> '" * '^ - .      

GolfScript, 14

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

Comment ça marche: ASCII se passe comme ça:

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

Donc, cela prend les codes ASCII de chaque caractère, en soustrait cinq et les colle dans une chaîne.

{...}%donne un tableau des caractères d'une chaîne mappée, quand une chaîne est donnée en argument. Ainsi, il incrémente chaque caractère de 5 ( )signifie incrémente).

Python, 32 caractères

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

Probablement possible de le réduire en utilisant le caractère Unicode 2014 ߞ, mais je n'ai pas essayé.

Quincunx note que

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

est plus court de trois caractères.

APL (6 octets, 4 caractères)

⊃⎕TS

Ne fonctionne que cette année si.

Pourquoi ça marche:

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

Sans compter sur la date du système, il s'agit de 10 octets (7 caractères):

⎕UCS'ߞ'

Python 32 10 octets, 91 à 85 (66 avec mathimportés par défaut) octets mathématiques pures

J'ai eu du plaisir à écrire ceci:

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)

Imprime toutes les manières possibles que je peux écrire en 2014utilisant la méthode de Bruno Le Floch (32 caractères):

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

Mais ceci est évidemment redondant, donc si votre interprète est configuré par défaut sur utf-8, alors tout ce qu'il faut est:

>>> ord(u'ߞ')
2014

Aussi, grâce à AmeliaBR (pour l'idée), j'ai fait de mon mieux pour implémenter une version mathématique pure:

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 caractères)

@popojan (il n'est pas autorisé à poster une réponse ici) a fourni la solution avec 20 caractères maximum.

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

Sortie:

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

R (22 caractères)

Utilisateur anonyme a suggéré une solution plus courte.

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

2014est BBCen base 13. pi*pi+pi(= 13.0112) est traité par R dans ce contexte comme le nombre entier 13. Résultat:

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

R (30 caractères)

Merci à @Tomas!

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

Sortie:

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

R (31 caractères)

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

Inspiré de la réponse d'AmeliaBR . Sortie:

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

Java - 77 75 caractères

75 caractères si printest ajouté dans une classe avec la méthode main:

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

Cela signifie 35*60-86ce qui est égal à 2014