Nota para desafiar a los escritores según el meta consenso : esta pregunta fue bien recibida cuando se publicó, pero desafíos como este, pedir a los respondedores que hagan X sin usar Y probablemente sean mal recibidos. Intente usar el sandbox para obtener comentarios sobre si desea publicar un desafío similar.

Ya es 2017 2018 2019, amigos, vete a casa.

Entonces, ahora que es 2014, es hora de una pregunta de código que involucra el número 2014.

Su tarea es hacer un programa que imprima el número 2014, sin usar ninguno de los caracteres 0123456789en su código, e independientemente de cualquier variable externa como la fecha o la hora o una semilla aleatoria.

El código más corto (contando en bytes) para hacerlo en cualquier idioma en el que los números sean tokens válidos gana.

Tabla de clasificación:

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>

Ratón-2002 , 4 bytes.

Eso es 4 bytes de puro, dulce ASCII.

En Mouse , las letras del alfabeto se inicializan a los valores 0-25. !es el operador para imprimir enteros, por lo tanto, esto imprime 20entonces 14(no hay nueva línea intermitente).

U!O!

No hay un intérprete en línea disponible, pero aquí encontrará un intérprete escrito en C (que necesita algunos ajustes antes de poder obligarlo gcca compilarlo) y el mismo intérprete compilado Win32pero que funciona perfectamente en Linux wine.

Aquí puede encontrar la versión fija del intérprete, que compila.

Python, 52 bytes

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

Actualizado para 2015 gracias a @Frg:

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

Pase el mouse para ver la versión 2016:

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

Pruébalo en línea!

Befunge 98 - 17 11 9 8 bytes

'-:*b-.@

Similar a la versión anterior, pero me acordé 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

Curiosamente, 45 ² -11 es el único par de números a, b donde La importancia de esos conjuntos es que [32,126] es el conjunto de caracteres ascii imprimibles y [10,15] es el conjunto de números Befunge fácilmente accesibles. Encontré ese par coneste programa de Python:

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

O, si su intérprete es compatible con Unicode, entonces esto funciona:

Befunge 98 - 5 bytes (4 caracteres)

'ߞ.@

Al menos funciona en http://www.quirkster.com/iano/js/befunge.html con el siguiente código (Befunge 93 - 6 bytes / 5 caracteres):

"ߞ".@

Versión antigua

cdd**e-.@

calcula el número, luego lo 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

Versión antigua:

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

Empuja los valores ASCII para 2014, -10. Luego imprime cada uno después de agregarle 10.

Ruby, 15

p Time.new.year

Temporal;)

Tenga en cuenta que la sección de la pregunta

independientemente de cualquier variable externa como la fecha o la hora o una semilla aleatoria

no fue editado hasta mucho después de que publiqué mi respuesta ...

Jan Dvorak ofrece una gran alternativa en los comentarios :

Happy = Time
Happy.new.year

Pero es muy poco entusiasta. Yo prefiero:

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

Happy.new.year!

O incluso:

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!

Y aquí está la puntuación correcta en inglés:

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!

Vale, vale, no pude evitarlo:

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!

Ir, 2 bytes (UTF-16)

Un carácter unicode (2 bytes en UTF-16, 3 bytes en formato UTF-8), salida 2014 como parte de un error

—

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 caracteres, 5 bytes)

Puede aprovechar el sistema de tipos relativamente débil de MATLAB (y Scala), aquí. El truco consiste en aplicar la +operación unaria en una cadena compuesta solo por el carácter ߞ(del punto de código UTF-8 U + 07DE o 2014 en decimal). Esta operación convierte implícitamente la cadena en un doble (en MATLAB) y en un Int(en Scala):

+'ߞ'

Detalles de conteo de bytes:

• + es ASCII y cuenta para 1 byte
• ' es ASCII y cuenta para 1 byte (pero aparece dos veces en la expresión)
• ߞ es un carácter UTF-8 de 2 bytes

Total: 5 bytes

TeX (32 26 caracteres, tantos bytes)

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

Una alternativa aún más corta (propuesta por Joseph Wright ) es

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

XeTeX / LuaTeX (13 caracteres, 14 bytes)

Si se permiten XeTeX o LuaTeX, la entrada UTF-8 se puede usar directamente (como lo propuso Joseph Wright ):

\number`ߞ\bye

dc, 6 caracteres

DiBBCp

• D empuja 13 en la pila, incluso aunque la raíz de entrada sea 10 inicialmente
• i cambia la raíz de entrada (a 13 de 10)
• BBC es 2014 base 13.
• p huellas dactilares.

Salida de consola:

$ dc <<< "DiBBCp"
2014

Código Morse, 23

;)

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

72 45 caracteres en el código; Códigos de caracteres cero

Esto está lejos de ser la respuesta más corta publicada, pero nadie ha publicado aún una respuesta que

• no usa códigos de caracteres como sustituto de números, y
• no llama a la fecha del sistema.

Usando matemática pura (está bien, y una conversión booleana automática) en R, desde la consola R:

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

Imprime el número 2014. Tes un sinónimo predefinido para verdadero en R. Las funciones floory expestán disponibles directamente en el paquete base, al igual que la piconstante. R no tiene un operador de incremento, pero la repetición (x*x)resultó ser menos caracteres que el incremento y decremento dos veces cada uno.

Versión original en Javascript (72 caracteres)

Por la simple razón de que podría probar en la consola, y no le importa la falta total de espacios en blanco:

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

ejecute en su consola e imprimirá el número 2014.

Apoyos para xkcd (y también ) para hacerme pensar en exp (pi):

PD: Si puede acortar el mismo algoritmo en un idioma diferente, publique un comentario con él.

Scala REPL

34 29 caracteres.

+"Happy new year to you!".sum

Bueno, si realmente quieres jugar golf con cualquier carácter, puedes usar:

'@'*' '-'"'

o

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

que tienen 11 y 22 caracteres respectivamente.

PHP, 9 bytes

Esto requiere PHP 7.1 o inferior. Funcionará en PHP 7.2, pero generará una advertencia. No hay garantías para ninguna versión futura.

xxdnecesario debido a los datos binarios (por lo que copiar y pegar sería más fácil). Puede volver E_NOTICE, pero realmente no importa, ¿verdad?

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

Alternativamente, guarde esto usando la codificación ISO-8859-1.

<?=~ÍÏÎË;

C, 33 bytes

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

Mathematica, 14 caracteres (o 15 si cuenta el mapa de bits como un carácter)

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

Utiliza la conversión de base 64

alert(atob("MjAxNA=="))

23 caracteres (16 con atob solo)

O

alert("MMXIV") // ;)

Perl - 10 caracteres

Esta solución es cortesía de BrowserUK en PerlMonks , aunque eliminé algunos signos de puntuación y espacios en blanco innecesarios de la solución que publicó. Es un "no" bit a bit en una cadena binaria de cuatro caracteres.

say~"ÍÏÎË"

Los caracteres que se muestran arriba representan los octetos binarios cd: cf: ce: cb, y son como aparecen en ISO-8859-1 e ISO-8859-15.

Aquí está el script completo en hexadecimal, más un ejemplo ejecutándolo:

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

Perl (sin bits altos) - 14 caracteres

say'````'^RPQT

Utiliza un "o" bit a bit en las dos cadenas de cuatro caracteres "RPQT"y "````"(es decir, cuatro 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

(Inicialmente tenía las dos cadenas al revés, lo que requería espacios en blanco entre printy RPQTpara separar las fichas. @DomHastings señaló que al cambiarlas podría salvar un personaje).

Perl (trampa) - 8 personajes

Probablemente esto no esté dentro del espíritu de la competencia, pero hdb en PerlMonks ha señalado que Perl proporciona una variable llamada $0que contiene el nombre del programa actual que se está ejecutando. Si se nos permite nombrar el archivo que contiene el script "2014", entonces $0será igual a 2014. $0contiene un dígito, por lo que no podemos usarlo directamente, pero ${...}contener una expresión que evalúe a 0 estará bien; por ejemplo:

say${$|}

Por coherencia, hagamos lo hexcat-then-perl con eso:

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

Creo que esto es trampa, pero es una solución interesante, así que vale la pena mencionarlo.

Rubí, 20

p 'bbc'.to_i ?\r.ord

Explicación: bbcestá 2014en la base 13. Más corta que Python. No tan corto como Forth.

Powershell, 9

+"ߞ"[""]

ߞ( U + 07DE NKO LETTER KA ) se cuenta como dos bytes de acuerdo con la información de la etiqueta de código de golf .

[""]devuelve el primer carácter de la cadena ( ""se convierte a 0). El unario más opeartor ( +) convierte el carácter en un entero.

Scala REPL - 6 caracteres

"?="##

( ##es el significado del símbolo de Scala hashCodey la cadena de Java"?=" hasta 2014).

Scala REPL - 4 caracteres, 5 bytes

+'ߞ'

Matemáticas en nuestro personaje Unicode favorito produce un Int.

Javascript, 18 caracteres

alert(btoa('ÛMx'))

Actualización: en ES6, el uso de una plantilla literal puede guardar dos caracteres:

alert(btoa`ÛMx`)

El código anterior es bastante fácil de entender teniendo en cuenta que btoaconvierte una cadena en otra cadena de acuerdo con un conjunto de reglas bien definidas ( RFC 4648 ). Para ver cómo funciona la conversión, vamos a escribir la cadena de entrada "ÛMx" como una secuencia de dígitos binarios, donde cada carácter se representa como su código de carácter de 8 bits.

Carácter de entrada | Û | M | X
Código de caracteres (decimal) | 219 77 | 120
Código de caracteres (binario) | 11011011 | 01001101 | 01111000

Después de reorganizar los dígitos binarios en la última fila en grupos de 6, obtenemos la representación binaria de 4 números nuevos, correspondientes a los índices Base64 de los 4 caracteres en la cadena "2014".

Índice Base64 (binario) | 110110 | 110100 | 110101 | 111000
Índice Base64 (decimal) | 54 52 | 53 56
Carácter de salida | 2 | 0 | 1 | 4 4

Según la especificación HTML, los caracteres de salida se pueden recuperar de sus índices Base64 de acuerdo con esta tabla: http://dev.w3.org/html5/spec-LC/webappapis.html#base64-table .

Si no le importan los detalles, puede dejar que el navegador haga los cálculos por usted y descubra que "ÛMx" es el resultado de la evaluación atob('2014')en Javascript.

Otra entrada más de GolfScript, 9 caracteres imprimibles

Creo que esto es más corto que cualquiera de las entradas de GolfScript imprimibles hasta ahora:

"!="{*}*)

( La entrada de 7 caracteres de Peter Taylor lo supera, pero incluye caracteres de control no imprimibles).

Yo llamo a esto el "eso es por lo que el año pasado!" entrada, porque lo que realmente hace es generar el número 2013 en 8 caracteres, como 33 × 61, y luego lo incrementa en 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');}

Adelante, 14

'> '" * '^ - .      

GolfScript, 14

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

Cómo funciona: ASCII dice así:

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

Entonces, esto toma los códigos ASCII de cada carácter, resta cinco y los pega en una cadena.

{...}%produce una matriz de los caracteres de una cadena asignada, cuando se le da una cadena como argumento. Entonces, incrementa cada carácter en 5 ( )significa incremento).

Python, 32 caracteres

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

Probablemente sea posible reducirlo usando el 2014 th Unicode char ߞ, pero no lo intenté.

Quincunx señala que

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

es más corto por tres caracteres.

APL (6 bytes, 4 caracteres)

⊃⎕TS

Sin embargo, solo funciona este año.

Por qué funciona

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

Sin depender de la fecha del sistema, son 10 bytes (7 caracteres):

⎕UCS'ߞ'

Python 32 10 bytes, 91 85 (66 con mathimportados por defecto) bytes matemática pura

Me divertí mucho escribiendo esto:

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 todas las formas posibles en que puedo escribir 2014usando el método de Bruno Le Floch (32 caracteres):

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

Pero esto es obviamente redundante, por lo que si su intérprete está configurado en utf-8 por defecto, todo lo que necesita es:

>>> ord(u'ߞ')
2014

Además, gracias a AmeliaBR (por la idea), hice todo lo posible para implementar una versión matemática 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 caracteres)

@popojan (todavía no puede publicar una respuesta aquí) ha proporcionado la solución en 20 caracteres.

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

Salida:

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

R (22 caracteres)

El usuario anónimo ha sugerido una solución más corta.

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

2014está BBCen la base 13. pi*pi+pi(= 13.0112) es tratado por R en este contexto como el entero 13. Salida:

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

R (30 caracteres)

Gracias a @Tomas!

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

Salida:

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

R (31 caracteres)

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

Inspirado en la respuesta de AmeliaBR . Salida:

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

Java - 77 75 caracteres

75 caracteres si printse agrega en una clase con el método principal:

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

Significa 35*60-86que es igual a 2014