Reciclagem para o Ano Novo

23

Uma boa resolução para 2015 é viver de forma mais sustentável. Vamos começar pela reciclagem. Código de reciclagem, é isso!

Sua tarefa é imprimir o número 2015em STDOUT, com ou sem nova linha (e somente isso). No entanto, você deve fazer isso reciclando algum código antigo do PPCG. Aqui está como isso funciona:

  • Escolha qualquer resposta postada no CodeGolf.SE antes de 16/12/2014 00: 00: 00Z (o dia em que publiquei isso na sandbox). Exceção: Você não pode usar nenhuma resposta do desafio do ano novo do ano passado .
  • Escolha um bloco de código dessa resposta (não um trecho de código embutido, ele deve ser um parágrafo próprio). Esse bloco deve ser anunciado como código real, por exemplo, você não pode usar casos de teste ou exemplo de saída que, por acaso, use formatação monoespaçada.
  • Reorganize os caracteres nesse bloco de código para formar seu envio para esse desafio. Você só pode alterar a ordem, não adicionar ou remover caracteres. Isso inclui novas linhas.
  • Você deve poder mostrar que o bloco de origem original é sintaticamente válido no seu idioma. Na melhor das hipóteses, você pode fazer isso mostrando que ele é executado sem erros de tempo de compilação ou de tempo de execução. Portanto, embora o código original possa ter sido Java, você pode usá-lo para uma resposta em espaço em branco (como todos os arquivos são válidos em espaço em branco), mas provavelmente não pode usá-lo para uma resposta em Python (pois o original não será uma sintaxe válida em Python) )

Observe que sua resposta deve ignorar todas as entradas e estados externos (incluindo a data atual real). Ele pode ler de STDIN, digamos, desde que ele não falhar se ele está vazio, e produz a mesma saída para todos os conteúdos possíveis do fluxo.

Seu código resultante deve ser um programa completo (não uma função nem um trecho que assuma um ambiente REPL).

Isso é código de golfe, então a resposta mais curta (em bytes ) vence.

Classificação

Tenho certeza de que isso ocorrerá de maneira muito diferente em diferentes idiomas. Portanto, o seguinte snippet de pilha gera uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Mostrar snippet de código

code-golf number restricted-source new-years Martin Ender
fonte
Nem todo programa Whitespace é válido; Eu obtive um erro para ideone.com/Jphkf3
Ypnypn
Esta pergunta veio à minha mente: é permitido reciclar o código original de maneira que você comente uma grande parte do original?
precisa saber é o seguinte
@ProgramFOX sim, porque se você tiver que comentar muito, isso provavelmente prejudicará sua pontuação.
Martin Ender
@Ypnypn Isso parece um erro de tempo de execução para mim, não um erro de sintaxe, certo?
Martin Ender

Respostas:

22

GolfScript, 9 bytes

A resposta original (dibs!) Também está no GolfScript, que é como eu sei que é sintaticamente válida. Eu testei em http://golfscript.apphb.com/ .

2015}{.**

Detesto o uso de idiomas projetados para o golfe, mas tive que vencer esse desafio, por isso traí meus valores postando esta resposta. Eu não sei o que a maioria dos personagens faz nessa linguagem, mas uma vez aprendi inadvertidamente, enquanto deslizava uma resposta do GolfScript, que um }comentário incomparável fora do restante do programa. Isso me permitiu ignorar o resto dos personagens.

feersum
fonte
1
Nunca pensei que aparelhos inigualáveis ​​seriam válidos para GS.
Martin Ender
3
@ MartinBüttner Você nunca viu isso?
FryAmTheEggman
16

Befunge-93, 2085 bytes

Eu pensei que iria me divertir e ir meta, reciclando o melhor dos reciclados . Não vou a nenhum prêmio por brevidade aqui.

+2012+1+1e1 or b+bbv+b+NN
"a"""""
p((('?'.ord-' '.ord )/(1.0/'A'.ord)).to_i)
<<id
                   1
                   !
                   _"  fabaaaca"-.-.-.-.+"O"2::++p

aa
AaAAaAAaAAaAAaA
eEe ddd OoOOoOOoOOoOOoOOoOOoOOoOOoOOoO ddD Ccc eEE
ccc LLl
SssSss LLl
SsS LLl
SsSSsSSsSSsS LLl
cccccc
mMm



+   +     a     pppp  pppp  y   y     n   n eeeee +     +    y   y eeeee     a     rrr    "
+   +    a a    p   p p   p  y y      nn  n e      + + +      y y  e        a a    r  r   "
+++++   aaaaa   pppp  pppp    y       n n n eee    + + +       y   eee     aaaaa   rrr    "
+   +  a     a  p     p       y       n  nn e       + +        y   e      a     a  r  r
+   + a       a p     p       y       n   n eeeee   + +        y   eeeee a       a r  r   "



Hope to see another round of awesome programming puzzles and code golf challenges

===============================
"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' ' ' ' '

Big char dump below (will clean up if there's more languages to squeeze in):

  $$$$$$$()++++++++++++++++++++++++++++--------------------------/////:::;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<>>>>>??AAACCDDEEEFHHLLMMMMM
NOOOOOOOOOOORRRRRRRRRSSSUUUUV[\]___aaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbcccccccccccccddddddddddddddddddddddddddddddddddddddd
ddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeee
eeeeeeeeeeeeeeeeeeffffffffffghhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiilll
llllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnn
nnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppp
ppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssss
ssssssssssssssssssssssssstttttttttttttttttttttttttttttttttttttttttttttttttt
ttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
uuuuuuuuuuuuvvvvvvvvwwxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy
yyyyyyyyyyzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

"""
one=1
print(int(ord('A')/(one/(ord(' ')-one))))
id
"mOO"

Na verdade, este também é um poliglota para 5 idiomas: Befunge-93 , oOo Code , Pyth , Python 3 e Ruby. No entanto, como o código original é apenas sintaticamente válido para o Befunge-93, só estou contando isso.

Infelizmente, o código original tinha apenas um par []e muitos .s, então eu não consegui encaixar o Brainfuck (daí o ooo Code).

Notas

Isso acabou surpreendentemente restritivo, porque:

  • O conjunto completo de dígitos disponíveis é 001111111222, exigindo o uso de ordRuby e Python. Em particular, não há 5, o que acabou sendo uma dor para Pyth.
  • A falta de @meios que pprecisavam ser usados ​​para colocar um @no Befunge.
  • A falta de *significou que tivemos que multiplicar dividindo pelo inverso de um número. Diversão.

Befunge-93

O programa Befunge é

                   v
                   1
                   !
                   _"  fabaaaca"-.-.-.-.+"O"2::++p

onde pulamos as instruções inúteis. Nós codificar cada dígito como a diferença em valores ASCII entre caracteres, especificamente cabfvs a.

Código oOo

O BF correspondente é

>><->>->>>><>+++++[>++++++++++<-]>.--.+.++++.>>[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>->>>>>>>>>>>>>>>>>>>>>>->>>>>>>>>>>>>>>>>><;;;;;;;;;;;;;;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>->>>]

, dos quais a única parte relevante é

+++++[>++++++++++<-]>.--.+.++++.

Pyth

Pyth executa apenas a primeira linha, então

+2012+1+1e1 or b+bbv+b+NN

Note que Pyth usa uma notação de prefixo, então a primeira parte da linha é realmente

2012 + (1 + (1 + (1 % 10)))

( Nota: esignifica%10 )

Devido à natureza de Pyth, isso é impresso automaticamente. O restante da linha é Pyth válido, mas o espaço anterior a osuprime a impressão automática.

Python 3

A maioria do código Python é comentada usando cadeias, especialmente uma grande cadeia de citação tripla no meio. Ignorando algumas seqüências perdidas, temos:

+2012+1+1e1 or b+bbv+b+NN
"""
...
"""
one=1
print(int(ord('A')/(one/(ord(' ')-one))))
id

A primeira e a última linha são sintaticamente válidas, mas não fazem nada. As duas linhas do meio imprimem o que precisamos.

Rubi

O código Ruby é semelhante, mas estamos usando um heredoc em vez de uma cadeia de caracteres tripla para comentar a maior parte do programa. Ignorando algumas strings perdidas, temos:

+2012+1+1e1 or b+bbv+b+NN
p((('?'.ord-' '.ord )/(1.0/'A'.ord)).to_i)
<<id
...
id

Mais uma vez, a primeira linha é sintaticamente válida, mas não faz nada. A segunda linha imprime o que precisamos.

Sp3000
fonte
4
Você definitivamente não recebe o prêmio "código mais curto", mas +1 por criatividade!
Maçaneta
11

CJam, 12 bytes

T~mp[]!_1+oE^

O tópico Desembaralhar o código é uma fonte realmente boa para impressão de números aleatórios. Este foi bastante divertido de juntar :)

T~     bitwise not of 0 is -1                     [-1]
mp     replace with 0 as -1 is not prime          [0]
[]!    not of an empty array (falsy) is 1         [0, 1]
_      copy that 1                                [0, 1, 1]
1+     add 1                                      [0, 1, 2]
o      output top of stack                        [0, 1]           2
E      push 14                                    [0, 1, 14]       2
^      bitwise xor                                [0, 15]          2
       (CJam implicitly prints stack afterwards)  []               2015

Respostas de bônus

14 bytes:

36.e8 .79e2%15

19 bytes:

0_*1_)@@{_%\_)*\};5
Sp3000
fonte
7

Avestruz, 198

Estou animado para obter uma resposta de avestruz; Eu não me importo quanto tempo isso leva. : P (esta é a versão 0.5.0 , a propósito)

{: rotate ( circ n -- )
    neg swap change-circular-start

IN: 1 9 [a,b] <circular> dup 6 rotate >array .
{ 4 5 6 7 8 9 1 2 3 }
IN: 1 9 [a,b] <circular> dup 3 rotate >array .
 7 8 9   3 4  6 };2 n15

Original :

: rotate ( circ n -- )
    neg swap change-circular-start ;

IN: 1 9 [a,b] <circular> dup 6 rotate >array .
{ 4 5 6 7 8 9 1 2 3 }
IN: 1 9 [a,b] <circular> dup 3 rotate >array .
{ 7 8 9 1 2 3 4 5 6 }

Tudo o que mudei foi o seguinte:

  • Quebra automática de tudo, exceto 2 n15em um bloco ( {}) que é imediatamente exibido ( ;).

  • Preso 2 n15no final. 2empurra a 2, nempurra a 0e 15empurra 15, o que acaba se tornando 2015quando a saída.

Isso realmente me ajudou a encontrar um bug: 2n15não funciona por algum motivo (é impresso 215), mas ambos 2 n15e 2n 15funcionam. Vou ter que descobrir por que isso é ....

Aqui está a consulta de pesquisa que eu usei para encontrar esse exemplo de código perfeito:

criado: .. 16-12-2014 é: código de resposta: "2" código: "0" código: "1" código: "5" código: "]" código: ";"

Essa resposta funcionaria para 140, mas vou ver se consigo diminuir ...

Maçaneta da porta
fonte
7

JavaScript, 26 bytes

Original :

alert(998|(103>8>0&41>-0))

Reciclado:

alert(4030>>(998>1|8&1-0))

Apenas desloca 4030 um pouco para a direita.

grc
fonte
5

CJam, 14 bytes

Este é um pouco complicado, então eu tive que publicá-lo, embora seja um pouco longo. A resposta original também está no CJam, portanto é válida.

Resposta original:

92e8.17 5e6.3%

Reciclado 2015:

9.68e3 .7e2%15

Como funciona

9.68e3 is 9680
.7e2 is 70
9680 70% is 9680%70 = 20
15 is 15

Portanto, a pilha contém 20e 15é impressa uma após a outra, imprimindo 2015

Experimente online aqui

Optimizer
fonte
5

Marbelous, 54 bytes

Resposta chata (54 bytes)

32303135
:R
:Q
++003333333567QQRR}0

(seguido por uma tonelada de novas linhas à direita para igual a 54 bytes)

Resposta original

A placa principal simplesmente solta bolinhas de gude representando cada um dos caracteres de 2015. ReQ placas são definidas, mas nunca usadas.

Resposta alternativa (92 bytes)

3W!!?0]]>W/\&0&1@1@0@0
      ]]>W/\&0&1@1@0@0
                @1  @0
03  02
\\  //
32+A
  Dp

Resposta original

Espaços como células em branco devem ser verificados. Isso primeiro imprime 2(0x32), depois imprime 0x03+0x02+0x0A=0x0F=15como um decimal de três dígitos ( 015). As três primeiras linhas não fazem nada.

Teste as respostas aqui.

es1024
fonte
4

Pyth, 25

https://github.com/isaacg1/pyth

J6ifqT++2010/JJ4U*2^TJ^TT

Aqui está a resposta original (também escrita em pyth). Eu sei que essa não é uma resposta muito competitiva (existe uma resposta em python de comprimento 26), mas eu realmente gostei de sugerir isso, e acho que sai uma resposta bastante cômica.

Explicação:

J6                           : J=6
  i                   ^TT    : convert_to_base(..., 10 BILLION)
   fqT          U*2^TJ       : filter(lambda T: T==..., range(2*10^6)
      ++2010/JJ4             : 2010 + J/J + 4

Basicamente, isso está filtrando uma lista dos dois primeiros milhões de números por ser igual a 2015. Em seguida, trata essa lista de números como os dígitos de um número de 10 BILHÕES de base. Felizmente, existe apenas um número igual a 2015 no intervalo, então você obtém 2015 * 10000000000 ^ 0, que é apenas 2015. Isso leva alguns segundos para ser executado.

FryAmTheEggman
fonte
2

Mathematica, 60 bytes

⌊DF@IM~RS~ad~ee~ee~ggggiiimmnnoorrrstt~.22346⌋Print@2015

Fonte

A parte Floorentre parênteses é apenas uma série de aplicativos de funções de funções inexistentes (com as quais o Mathematica não tem problemas, devido ao seu modelo de computação simbólico). Da mesma forma, basta escrever o piso e a Print@2015multiplicação, da qual o Mathematica também não se queixa. Sem o açúcar sintático, seria

Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]] * Print[2015]

Como não estamos assumindo um ambiente REPL, o resultado avaliado nunca é impresso (o que seria Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), mas apenas o efeito colateral do Printitem realmente é STDOUT.

Obrigado ao Sp3000 por aumentar a fonte para isso.

Martin Ender
fonte
2

> <>, 57 bytes

Código C ++ original, do desafio RadioASCII :

#include <cstdio>
int main(){int x;printf("Lawrencium");}

Código > <> (Peixe) reciclado :

eclne)nfn;
   ""#(();<>Laaccddiiiiiiimmnnnoprrsttttuuwx{}

Como o Befunge,> <> é uma linguagem 2D baseada em pilha. A execução começa no canto superior esquerdo e é inicialmente para a direita. Somente a primeira linha do programa é executada, da seguinte maneira:

e      Push 14                          [14]
c      Push 12                          [14, 12]
l      Push the length of the stack     [14, 12, 2]
n      Output as num                    [14, 12]          2
e      Push 14                          [14, 12, 14]      2
)      Push 1 if greater than else 0    [14, 0]           2
n      Output as num                    [14]              20
f      Push 15                          [14, 15]          20
n      Output as num                    [14]              2015
;      Terminate                        [14]              2015

Agora, a grande questão é: por que o código C ++ é válido> <>? Em> <> existem maneiras de mudar a direção do fluxo do programa (afinal, é uma linguagem 2D):

^>v<     Arrows which direct program flow a certain direction
_/|\     Mirrors which reflect the direction of program flow
#        Four-way mirror, reflect from all directions

Quando o código C ++ é executado, a inicial #reflete o fluxo do programa para a esquerda. Como> <> é toroidal, o ponteiro da instrução se aproxima, aparecendo no final da linha, encontrando o >que direciona o fluxo do programa para a direita novamente. O ponteiro então volta para o #, retorna para >... e, portanto, ocorre um loop infinito e nunca é gerado um erro.

Sp3000
fonte
1

Python 3, 1878 bytes

Muito longo, mas queria compartilhar de qualquer maneira:

import sys,re,zlib as z,base64
print(2015)#,PIL.Image as ire.search(str(z.adler3(i.open(sys.argv[1]).tobytes()[2::6])%203)+'(\\D+',z.decompress(base64.b8decode(b'c${Tc%XZ>86NyfdNqBH<%b?iLI_EpFkwO-GfQC$tcfjoB$+h*^;0s?o$g*?uzgjxs%~BKif!C3zALZEU!&?wJd#-mqgS@p<P&+)AsV|c*52*C>U&(_4w^urvvWJU8Bj;bvv4ia;eiJLu+bsXLru`DjH|W<`|;xLq++kv5k8VWZgQe*`_u+opEF8>A6qjM%k#skzbiuJ7dL_*><K@9l6!M*H(|w)PZJ2`RYy7K2VVrv+zc)&2Fc?wvh|^#ksyymE?D!Q$3!LbFX%h%vT%1#lr486Iybw?0!`H)ZlZ#XIao2uXTr}(IBl@wRWHa#})bgV);O3HoW7+T*!5M3=^mu6Ri$`7L;uUWj~gsqR6gQR9h7^nKdBIgy>ats36%|M|8p1x;32(ZfK9R5_xK5ts=Sz70c%SIK&g3N1E|sg{n3>JSbKwwhssGcb$8uMNw=Nv;f_;rj?}kz(3-&#FQw@O;q(8nGHjbrTC(NQv=ckXT|eHr|amahCq(7T6<LBTr5Gj>fHV~3DcYINN!Qr`6Dl?jT>!4u5~bb%Zi6VTax;%vg*m325J_$nEC%yqbbYeEp!K_K7k)W-XCP`6+}N7tktMVX+{@c2L&kLAc&IvspGrzZ$F`uOBg}fA3W2neAU}tg~<+iCN=<sR^Zke+9WNhnCyy6!8nfa>33&OWiPt2s=OMTrUgilSYQxrG!gziB!Aj83zX&6S|yjIQkA?iF0n%?<+B=%_D11aoCv?@Q&eei{sqNkr7RG`#*xyzSUE6BUNnZK)3|3Wls}K$qaKv;jOO#!{3Ms)4CQ?shafnAF^zVq(`K9o2xL5JoQoGea+W1$+xmw&8OMOtN1Pid6UAcd+*_bB6IY$KjrO=ac^tPv3(8O`&(agOBbT{Va6s}Rm9&`I#yivC;MhW8=n+^^&Reho;~!~W<xgH6bVq3^=H7)sUXV2nv~DP4`CY`f55i&qH)DvPMQy>)y*Z=|68w@v=#oo5^RSh5R2F%1-vt>h=|+1n0pE^Yq-72!)1+o{hD_3<Cyxpyr6r%cei-AFQ*h1seM$MP>ovLS2k#Ci$to#do$s3MXu2lZsw~9HkbjVWM@1!{w>}LWVj#j2qC(+*Okc>=<qcV}*}+U_QK+(ZZ(x>ZMdDDWtgHiBK+7p6aHHI`u-h6z7|Xm`>D1t4uEp271y7oCI^{1^H~O7QRxTA_U&92Q8z$J2O|5Lbeg_0umd^pSU<%-ki7LtDvo&AgIt0h~6(y@Hr+kyLJ$<B#07KdGob0EW$7@f{GszaUv#tkpSyk759Khmvq-aiyM-_&x_VCTx$Vy<;$<k{T$-@{Mhc<<%KD1AHK^MKkg%pYIW}SxhV?&a{o9=rs@*+hqyoioE=TF>9S<KxY+^69^OA0jkS#0!w@kw4}KTcP9#+PVW+qB|7B`Y?eRs+7}8RSAs?i?-Cz#Wp(Iihd`nI!Q_i%R^o_;fvDQ5|{Cr;yWeirL>_l#(wn)$QenJkK6Sgw)5NleBzvo&G#@>X`7Ib*aS4LHx9epI%BXXV&y7LJ&54g}D25-Q8>DZQ5hGKyIeJkQQu08%j|<x~)q(AOVw9P~Z*c0Z@VM6n#<}tBT6+T%4mZ9f*y76xlEFM~o$xr9*SZHd^6D-C!pkkp3m(-~W3&>KY@106L+;I><MJ^Dz`f{(I3i?u`2pWjUjlwZx`B1JB#h#u3xTH*b1K?TG40|4lxF1$_Pw+t?h2')).decode()).group(1))

Retirado da resposta de KennyTM .

Vi que 2, 0, 1 e 5 e # podiam ser encontrados no código, então mudei alguns caracteres para fazer print(2015)e poderia comentar o resto. Também coloquei a importação PIL no comentário para que não exija essa biblioteca.

ProgramFOX
fonte
1

PHP, 21 bytes

<?=65*4*31*2/8;//7**9

Vamos tentar de novo. Retirado de outra resposta PHP de Decifrar o código-fonte. É bastante básico, mas até agora é o programa mais curto em um idioma que não seja golfe. Você pode verificá-lo em http://codepad.org/15EjIYAU . O código original é o seguinte:

<?=9*8*7*6*5*4/3/2/1;
NinjaBearMonkey
fonte
Você nem precisa do 4*2/8;)
Martin Ender
Eu sei, mas eu queria torná-lo mais interessante, e teria sido comentado de qualquer maneira.
NinjaBearMonkey