Nota para desafiar os escritores de acordo com o meta consenso : Esta pergunta foi bem recebida quando foi publicada, mas desafios como esse, pedir respostas ao Do X sem usar Y provavelmente serão mal recebidos. Tente usar a sandbox para obter feedback, se você quiser postar um desafio semelhante.

Já é 2017 2018 2019, pessoal, vão para casa.

Então, agora que é 2014, é hora de uma pergunta de código envolvendo o número 2014.

Sua tarefa é criar um programa que imprima o número 2014, sem usar nenhum dos caracteres 0123456789no seu código, e independentemente de quaisquer variáveis ​​externas, como data ou hora ou uma semente aleatória.

O código mais curto (contando em bytes) para fazê-lo em qualquer idioma em que os números sejam tokens válidos vence.

Entre os melhores:

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.

São 4 bytes de puro e doce ASCII.

No mouse , as letras do alfabeto são inicializadas com os valores de 0 a 25. !é o operador para imprimir inteiros, assim este gravuras 20em seguida 14(nenhuma nova linha intermitente).

U!O!

Não há intérprete on-line disponível, mas aqui você encontrará um intérprete escrito em C (que precisa de alguns ajustes antes que se possa coagir gccpara compilá-lo) e o mesmo intérprete compilado, Win32mas que funciona perfeitamente no Linux wine.

Aqui você pode encontrar a versão fixa do intérprete, que é compilada.

Python, 52 bytes

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

Atualizado para 2015 graças a @Frg:

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

Passe o mouse sobre a versão 2016:

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

Experimente online!

Befunge 98 - 17 11 9 8 bytes

'-:*b-.@

Semelhante à versão antiga, mas lembrei 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 é o único par de números a, b onde A significância desses conjuntos é que [32,126] é o conjunto de caracteres ascii imprimíveis e [10,15] é o conjunto de números Befunge facilmente acessíveis. Eu encontrei esse par com este programa python :

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

Ou, se o seu intérprete suportar unicode, isso funcionará:

Befunge 98 - 5 bytes (4 caracteres)

'ߞ.@

Pelo menos, funciona em http://www.quirkster.com/iano/js/befunge.html com o seguinte código (Befunge 93 - 6 bytes / 5 caracteres):

"ߞ".@

Versão antiga

cdd**e-.@

calcula o número e depois o 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

Versão antiga:

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

Empurra os valores ascii para 2014, -10. Em seguida, imprime cada um após adicionar 10 a ele.

Ruby, 15

p Time.new.year

Temporário;)

Observe que a seção da pergunta

independentemente de quaisquer variáveis ​​externas, como data ou hora ou uma semente aleatória

não foi editado até muito tempo depois que eu postei minha resposta ...

Jan Dvorak oferece uma ótima alternativa nos comentários :

Happy = Time
Happy.new.year

Mas é tão pouco entusiasmado. Eu prefiro:

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

Happy.new.year!

Ou até:

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!

E aqui está a pontuação correta em 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!

Ok, ok, eu não pude evitar:

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)

Um caractere unicode (2 bytes em UTF-16, 3 bytes em formato UTF-8), saída 2014 como parte de um erro

—

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)

Você pode tirar proveito do sistema do tipo relativamente fraco do MATLAB (e Scala), aqui. O truque é aplicar a +operação unária em uma sequência composta apenas pelo caractere ߞ(do ponto de código UTF-8 U + 07DE ou 2014 em decimal). Esta operação converte implicitamente a string em um duplo (no MATLAB) e em um Int(no Scala):

+'ߞ'

Detalhes da contagem de bytes:

• + é ASCII e conta com 1 byte
• ' é ASCII e conta com 1 byte (mas aparece duas vezes na expressão)
• ߞ é um caractere UTF-8 de 2 bytes

Total: 5 bytes

TeX (32. 26 caracteres, tantos bytes)

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

Uma alternativa ainda mais curta (proposta por Joseph Wright ) é

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

XeTeX / LuaTeX (13 caracteres, 14 bytes)

Se o XeTeX ou o LuaTeX forem permitidos, a entrada UTF-8 poderá ser usada diretamente (como proposto por Joseph Wright ):

\number`ߞ\bye

dc, 6 caracteres

DiBBCp

• D empurra 13 na pilha, mesmo que o raio de entrada seja 10 inicialmente
• i altera o raio de entrada (de 13 para 13)
• BBC é 2014 base 13.
• p impressões.

Saída do console:

$ dc <<< "DiBBCp"
2014

Código Morse, 23

;)

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

72 45 caracteres no código; Zero códigos de caracteres

Isso está longe de ser a resposta mais curta publicada, mas ninguém postou ainda uma resposta que

• não usa códigos de caracteres como substitutos de números e
• não chama a data do sistema.

Usando matemática pura (ok, e uma conversão booleana automática) em R, no console do R:

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

Imprime o número 2014. Té um sinônimo predefinido para true em R. As funções floore expestão diretamente disponíveis no pacote base, assim como a piconstante. R não possui um operador de incremento, mas repetir o (x*x)número de caracteres que menos incrementa e diminui duas vezes cada.

Versão original em Javascript (72 caracteres)

Pela simples razão de que eu poderia testar no console, e ele não se importa com uma completa falta de espaço em branco:

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

executar no seu console e imprimirá de volta o número 2014.

Adereços para xkcd (e também ) para que eu pense sobre exp (pi):

PS Se você pode tornar o mesmo algoritmo mais curto em um idioma diferente, poste um comentário com ele.

Scala REPL

34 29 caracteres.

+"Happy new year to you!".sum

Bem, ok, se você realmente quer jogar golfe com algum caractere, pode usar:

'@'*' '-'"'

ou

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

que possuem 11 e 22 caracteres, respectivamente.

PHP, 9 bytes

Isso requer PHP 7.1 ou inferior. Ele funcionará no PHP 7.2, mas resultará em um aviso. Não há garantias para nenhuma versão futura.

xxdnecessário devido a dados binários (para copiar e colar seria mais fácil). Pode voltar E_NOTICE, mas isso realmente não importa, não é?

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

Como alternativa, salve isso usando a codificação ISO-8859-1.

<?=~ÍÏÎË;

C, 33 bytes

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

Mathematica, 14 caracteres (ou 15, se você contar o bitmap como um caractere)

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

Usa a Conversão Base 64

alert(atob("MjAxNA=="))

23 caracteres (16 com atob por si só)

Ou

alert("MMXIV") // ;)

Perl - 10 caracteres

Esta solução é cortesia do BrowserUK no PerlMonks , embora eu tenha excluído algumas pontuações e espaços em branco desnecessários da solução que ele postou. É um "não" bit a bit em uma string binária de quatro caracteres.

say~"ÍÏÎË"

Os caracteres exibidos acima representam os octetos binários cd: cf: ce: cb e são como eles aparecem nas ISO-8859-1 e ISO-8859-15.

Aqui está o script inteiro em hexadecimal, além de um exemplo executando-o:

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

Perl (sem bits altos) - 14 caracteres

say'````'^RPQT

Isso usa um bit a bit "ou" nas duas seqüências de quatro caracteres "RPQT"e "````"(isto é, quatro reticulares).

$ ~/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, eu tinha as duas strings ao contrário, o que exigia espaço em branco entre printe RPQTpara separar os tokens. @DomHastings apontou que, trocando-os, eu poderia salvar um personagem.)

Perl (trapaça) - 8 caracteres

Provavelmente isso não está dentro do espírito da competição, mas o hdb no PerlMonks apontou que o Perl fornece uma variável chamada $0que contém o nome do programa atual sendo executado. Se for permitido nomear o arquivo que contém o script "2014", $0será igual a 2014. $0contém um dígito; portanto, não podemos usá-lo diretamente, mas ${...}conter uma expressão que avalia como 0 ficará OK; por exemplo:

say${$|}

Para maior consistência, vamos fazer a coisa hexcat-then-perl com isso:

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

Eu acho que isso é trapaça, mas é uma solução interessante, no entanto, vale a pena mencionar.

Ruby, 20

p 'bbc'.to_i ?\r.ord

Explicação: bbcestá 2014na base 13. Mais curta que Python. Não tão curto quanto Forth.

Powershell, 9

+"ߞ"[""]

ߞ( U + 07DE NKO LETTER KA ) é contado como dois bytes de acordo com as informações da tag code-golf .

[""]retorna o primeiro caractere da sequência ( ""é convertido em 0). O unário mais opeartor ( +) converte o caractere em um número inteiro.

Scala REPL - 6 caracteres

"?="##

( ##é o significado do símbolo de Scala hashCodee a cadeia de caracteres de Java é "?="hash para 2014.)

Scala REPL - 4 caracteres, 5 bytes

+'ߞ'

A matemática em nosso personagem unicode favorito produz um Int.

Javascript, 18 caracteres

alert(btoa('ÛMx'))

Atualização: no ES6, o uso de um literal de modelo pode salvar dois caracteres:

alert(btoa`ÛMx`)

O código acima é bastante fácil de entender, lembrando que btoaconverte uma string em outra string de acordo com um conjunto de regras bem definidas ( RFC 4648 ). Para ver como a conversão funciona, vamos escrever a sequência de entrada "ÛMx" como uma sequência de dígitos binários, onde cada caractere é renderizado como seu código de 8 bits.

Caractere de entrada | Û M x
Código de caracteres (decimal) | 219 77 120
Código de caractere (binário) | 11011011 01001101 01111000

Após reorganizar os dígitos binários na última linha em grupos de 6, obtemos a representação binária de 4 novos números, correspondendo aos índices Base64 dos 4 caracteres na cadeia "2014".

Índice Base64 (binário) | 110110 110100 110101 111000
Índice Base64 (decimal) | 54 52 53 56.
Caractere de saída | 2 0 1 | 4

Conforme a especificação HTML, os caracteres de saída podem ser recuperados de seus índices Base64 de acordo com esta tabela: http://dev.w3.org/html5/spec-LC/webappapis.html#base64-table .

Se você não se importa com os detalhes, pode deixar o navegador fazer os cálculos e descobrir que ""Mx" é o resultado da avaliação atob('2014')em Javascript.

Mais uma entrada GolfScript, 9 caracteres imprimíveis

Acredito que isso seja mais curto do que qualquer uma das entradas imprimíveis do GolfScript até agora:

"!="{*}*)

( A entrada de 7 caracteres de Peter Taylor supera, mas inclui caracteres de controle não imprimíveis.)

Eu chamo isso de "isso é tão no ano passado!" entrada, porque o que ele realmente faz é gerar o número 2013 em 8 caracteres, como 33 × 61 e, em seguida, incrementa-o em um. ;-)

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

Quarto, 14

'> '" * '^ - .      

GolfScript, 14

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

Como funciona: o ASCII é assim:

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

Portanto, isso pega os códigos ASCII de cada caractere, subtrai cinco e coloca-os em uma string.

{...}%produz uma matriz dos caracteres de uma sequência mapeada, quando recebe uma sequência como argumento. Portanto, incrementa cada caractere em 5 ( )significa incremento).

Python, 32 caracteres

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

Provavelmente é possível reduzi-lo usando o char Unicode de 2014 ߞ, mas não tentei.

Quincunx observa que

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

é mais curto em três caracteres.

APL (6 bytes, 4 caracteres)

⊃⎕TS

Só funciona este ano.

Por que funciona:

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

Sem contar com a data do sistema, são 10 bytes (7 caracteres):

⎕UCS'ߞ'

Python 32 10 bytes, 91 85 (66 com mathimportados por padrão) matemática pura

Diverti-me escrevendo isso:

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 as formas possíveis de escrever 2014usando o 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

Mas isso é obviamente redundante; portanto, se o seu intérprete estiver definido como utf-8 por padrão, basta que:

>>> ord(u'ߞ')
2014

Além disso, graças a AmeliaBR (pela ideia), tentei o meu melhor para implementar uma versão 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 (ele ainda não está autorizado a postar uma resposta aqui) forneceu a solução em até 20 caracteres.

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

Resultado:

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

R (22 caracteres)

Usuário anônimo sugeriu uma solução mais curta.

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

2014está BBCna base 13. pi*pi+pi(= 13.0112) é tratado por R neste contexto como o número inteiro 13. Saída:

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

R (30 caracteres)

Graças a @Tomas!

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

Resultado:

> 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 na resposta de AmeliaBR . Resultado:

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

Java - 77 75 caracteres

75 caracteres se printforem adicionados em uma classe com o método principal:

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

Isso significa 35*60-86que é igual a 2014