在源代码中生成没有任何数字的数字2014


579

根据元共识向挑战者发出的注释:这个问题在发布时就很受欢迎,但是像这样的挑战(要求回答者在不使用Y的情况下进行X回答) 很可能会被接受。 如果您要发布类似的挑战,请尝试使用沙盒获取反馈。


这是2017年 2018 2019已经,乡亲们,回家了。

因此,现在是2014年,是时候讨论涉及数字2014的代码了。

您的任务是制作一个打印数字的程序2014,而无需使用0123456789代码中的任何字符,并且与任何外部变量(例如日期或时间或随机种子)无关。

以数字为有效令牌的任何语言执行的最短代码(以字节为单位)将获胜。


排行榜:


10
即使在脑力激荡中忽略了数字,我还是想还是发布一个。32个字符:++++++[>++++++++<-]>++.--.+.+++.
Braden最佳

4
Brainfuck不是应对这一挑战的有效语言。
Joe Z.

8
我想知道这个问题在新年前后的人气是否有小幅上升。
Joe Z.

3
等待“来吧,伙计,你不知道这是2016年吗?” :)
padawan

1
@BradenBest可以用至少两种不同的方式用31个字符来完成此操作:+++++++ [> +++++++ <-]> + .--。+。+++。和++++++++++ [> +++++ <-]> .--。+。+++。
Zubin Mukerjee,2016年

Answers:


126

Mouse-2002,4个字节。

这是4个字节的纯净甜美ASCII。

Mouse中,字母被初始化为值0-25。!是操作者用于打印整数,因此该打印20然后14(无间断换行)。

U!O!

没有可用的在线解释器,但是您会在这里找到用C编写的解释器(需要进行一些调整才能强制gcc编译),并且使用相同的已编译解释器,Win32但在上使用Linux可以完美运行wine

在这里,您可以找到编译器的固定版本。


7
哇,这是挑战赛结束后这么多的奇妙发现。语言如此深奥,这里还没有人听说过!
Joe Z.

3
顺便说一句:这与CJam的功能相同KE,但是实际上是有效的,因为它是2014
Joe Z.

7
在以最快的代码击败了Python的一些支持者之后,我脸上的自鸣得意的外观现在看起来像是Fortran-77向导。
2015年

55
这是@cat和Mouse-2002的游戏。
Digital Trauma

5
@DigitalTrauma确实是:3

1300

Python,52个字节

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

@Frg为2015年更新:

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

将鼠标悬停以查看2016版本:

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

在线尝试!


185
您应该获得聪明奖
Carter Pape 2014年

166
哇-这个问题的实质就是如此。<3
约翰内斯

80
令我惊讶的是,这只是我在“新年快乐!”之后尝试的第四个词,这对1374
来说

55
print sum(ord(c) for c in 'HAPPY NEW YEAR To you too.') 哦,等等,我迟到了一年。那是2013
。–沃伦·P

163
sum(map(ord,'Happy new year to you!'))将节省7个字符。

243

Befunge 98 - 17个 11 9 8字节

'-:*b-.@

与旧版本相似,但我记得 '

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

有趣的是,45 2 -11是唯一的一对数字a,b,其中 这些集合的意义在于,[32,126 ]是可打印的ascii字符集,[10,15]是易于访问的Befunge数字集。我发现这对与此python程序

(a,b)[32,126]×[10,15]a2b=2014
for a in range(32,127):
    for c in range(10,16):
        if (a**2-c)==2014:
            print("%s,%s"%(a,c))

或者,如果您的解释器支持unicode,则可以这样做:

Befunge 98-5个字节(4个字符)

'ߞ.@

它至少可以在http://www.quirkster.com/iano/js/befunge.html上使用以下代码运行(Befunge 93-6字节/ 5个字符):

"ߞ".@

旧版本

cdd**e-.@

计算数字,然后打印出来:

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

旧版本:

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

将2014年的ascii值推入-10。然后在每张纸上加10后打印。


78
zh.wikipedia.org/wiki/Befunge ...我什至不知道这是什么...
柏拉图

36
“语言最初是由克里斯·普雷西于1993年建立的一个尝试设计一种语言,是很难编越好” ......

7
@ 11684输出在问题中定义得很好。如果程序打印:randomstuff2randomstuff0randomstuff1randomstuff4我认为这不是有效的解决方案。
Cruncher 2014年

7
@Plato如果您想了解Befunge 98,请阅读官方规格
Justin

3
维基:“该语言最初是由克里斯·普莱斯(Chris Pressey)于1993年创建的,旨在设计一种尽可能难以编译的语言” ...但是为什么呢?
CousinCocaine 2014年

239

红宝石,15岁

p Time.new.year

临时的;)


请注意问题部分

独立于任何外部变量,例如日期或时间或随机种子

直到我发布答案很久之后才进行编辑...


Jan Dvorak在评论中提供了一个不错的选择:

Happy = Time
Happy.new.year

但这太不热情了。我更喜欢:

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

Happy.new.year!

甚至:

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!

这是正确的英语标点符号:

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!

好的,我无能为力:

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!

167
Happy = Time; Happy.new.year
John Dvorak 2014年

5
@hobbs不,不是;不是。问题对此一无所获
Doorknob

12
这只会在某些时候正常工作。
hippietrail 2014年

119
迄今为止,它在所有测试中都运行良好
CoderTao 2014年

7
我认为,问题的实质是说今年(今年恰好是2014年)。因此,该解决方案比接受的解决方案在时间上更“便携”;)。您(和Jan Dvorak)得到我的投票!
2014年

223

Go,2个字节(UTF-16)

一个Unicode字符(UTF-16中为2个字节,UTF-8格式中为3个字节),作为错误的一部分输出2014

http://ideone.com/dRgKfk

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

7
那是非常聪明的方法,但问题是需要一个打印数字的程序。
HelloGoodbye 2014年

40
如果印刷的错误代码很重要,则此提交应为获胜。
ToastyMallows 2014年

36
+1。问题不是说“ 打印数字,不打印其他任何内容”。
卡兹(Kaz)2014年

1
我不在乎它是否有效,这真棒。
Redwolf Programs

1
这是一个标准漏洞
MilkyWay90,

177

Python,26岁

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

53
英国广播公司是2014年以13为基数
达伦·斯通

70
我假设使用字符“ bbc”,而使用基数13是道格拉斯·亚当斯的致敬。“我可能会感到遗憾,但我不会以13为基数开玩笑。”
Brian Minton

10
13年前。RIP。
达伦·斯通

4
海事组织,这个答案是在“ True Pythonese”中
kmonsoor 2014年

8
@BrianMinton:使用Base 13可能是因为它是2到36之间的唯一基数,该基数允许表示2014的数字而没有任何字符0- 9
dan04 2014年

146

MATLAB,Scala(4个字符,5个字节)

您可以在此处利用MATLAB(和Scala)相对较弱的类型系统。技巧是将一元+运算应用于仅由字符组成的字符串ߞ(UTF-8代码点U + 07DE或十进制2014)。此操作将字符串隐式转换为double(在MATLAB中)和double Int(在Scala中):

+'ߞ'

字节数详细信息:

  • + 是ASCII并计数为1个字节
  • ' 是ASCII并计数为1个字节(但在表达式中出现两次)
  • ߞ 是2字节的UTF-8字符

总计:5个字节

TeX(32 26个字符,最多字节)

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

一个更短的选择(由Joseph Wright提出)是

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

XeTeX / LuaTeX(13个字符,14个字节)

如果允许使用XeTeX或LuaTeX,则可以直接使用UTF-8输入(由Joseph Wright提议):

\number`ߞ\bye

\let~\number~`^^T~`^^N\bye25个字符/字节。恕我直言,您算错了,您的解决方案也等于25。
2014年

1
@tohecz我认为我们两个解决方案实际上都是26字节长。
jub0bs 2014年

1
如果需要当前年份,则为13个字节:\the\year\bye
2014年

2
+'ߞ'也可以在Scala(和我想象的其他几种语言)中使用
2014年

118

dc,6个字符

DiBBCp
  • D 将13推入堆栈,即使输入基数最初为10
  • i 更改输入基数(从10更改为13)
  • BBC 是2014年的基数13。
  • p 打印。

控制台输出:

$ dc <<< "DiBBCp"
2014

10
是的,但是实际的dc程序仍然是DiBBCp(6个字符),其余只是运行它的一种方式。
daniero 2014年

11
我本来打算对此投票,但它有42分!使用基数13和单词BBC。多么酷啊!似乎今年我们会找到有关生命,宇宙和一切的问题;-) en.wikipedia.org/wiki/Base_13。我代之以@daniero的评论,并以42的宏伟声誉留下答案;-)
Pablo Marin-Garcia

4
@ PabloMarin-Garcia,很不幸,一个不为人知的人打破了它……现在有43票。请回去投票!:)
Tomas

3
@Tomas Vogons始终是Vogons。对银河系暴政的抵抗是徒劳的。
Pablo Marin-Garcia

2
我什至D在手册页中都找不到该命令。它有什么作用?没关系... d是十六进制的13
KZH

93

莫尔斯电码,23

;)

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

21
“使用任何数字作为有效标记的语言”
Doorknob

14
“ ..---”是5笔有效数字,代表第二个密码,对吗?就像“ 4”是有效的令牌一样,在三个笔划中代表数字“四个”。
DavidC 2014年

8
盲文可以更短:)
belisarius博士2014年

31
好点子。顺便说一句,我很放心,没有人问我如何让莫尔斯电码在我的计算机上运行。
DavidC 2014年

14
@DavidCarraher是什么意思?我自然假设您使用此存储库对其进行解码。github.com/Nyubis/mspa-morse-decoder每个人都在做...
Michael J. Calkins

88

72 代码中的45个字符;零字符代码

这远远不是发布的最短答案,但是还没有人发布答案

  • 不使用字符代码代替数字,并且
  • 不叫系统日期。

从R控制台在R中使用纯数学(好的,并且可以进行自动布尔转换):

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

打印出数字2014。 T是R中true的预定义同义词。floorexp函数以及pi常数直接在基本包中可用。R没有增量运算符,但重复执行后(x*x)发现重复的字符较少,每次重复执行两次。


Javascript的原始版本(72个字符)

出于简单的原因,我可以在控制台中进行测试,并且它并不介意完全缺少空格:

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

在控制台中运行,它将打印回数字2014。


道具XKCD(和)你为我想想EXP(PI): e到pi减去pi

PS:如果您可以用另一种语言来缩短相同算法的时间,请对其发表评论。


1
o =!“”;“((o + o)+”“ +(oo)+(o + oo)+(o + o + o + o)
内核James

4
25个字节:alert('ߞ'。charCodeAt())
oberhamsi 2014年

1
+1。但是,您声称您的答案是“不使用字符代码代替数字,也不称系统日期”的第一个答案。这实际上是错误的。我的答案有此解决方案cdd**e-.@(在您之前发布),它不使用字符代码或系统日期。它计算数字2014. cd和,e是十六进制数字。a,,b...,f(分别)推10,11,... 15 12 * 13 * 13 - 14,计算也是如此。
贾斯汀

这不是不使用字符代码的第一个答案。我有几个以前的。
Timtech

1
@Quincunx:你是对的;略读我没发现您的版本使用的是十六进制数字,而不是字符代码。
AmeliaBR 2014年

85

斯卡拉REPL

34 29个字符。

+"Happy new year to you!".sum

好吧,如果您真的希望将其与任何字符打高尔夫球,则可以使用:

'@'*' '-'"'

要么

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

分别具有11和22个字符。


4
有趣的想法,即使不是特别打高尔夫球。但是字符串本身使它比使用高字节的东西或类似的东西更有趣。
Konrad Borowski

我添加了一个高尔夫球版。
米卡·迈耶

您可以toInt像这样保存几个字符:+"Happy new year to you!".sum 测试
2014年

更新。我不知道+也可以是前缀。
麦克尔迈耶

68

PHP,9个字节

这需要PHP 7.1或更低版本。它可以在PHP 7.2中运行,但是会导致警告。不保证任何将来的版本。

xxd由于需要二进制数据(因此复制和粘贴会更容易)。可能会回来E_NOTICE,但这并不重要,对吗?

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

或者,使用ISO-8859-1编码保存此文件。

<?=~ÍÏÎË;

@Quincunx:上传此文件比较棘手,但这是Ideone-ideone.com/APHKhn
Konrad Borowski

1
这看起来很有趣;它有什么作用?
贾斯汀

7
@Quincunx:在字符串的每个字符上按位不(0x00变为0xFF,0x7F变为0x80)。由于字符串是有效的标识符(任何设置高位的字符都是PHP的标识符字符,可能支持其他编码),PHP认为它是一个常量,但由于未定义,因此将其视为字符串。
Konrad Borowski'14 2014年

2
由于问题是“现在是2014年……”,那又如何echo date('Y');呢?
约翰

6
@约翰:不。如果您阅读该问题的注释,则会注意到OP不想让该年份作为答案。此外,<?=date(Y);它将是11个字符,而我的解决方案是9个字符。
Konrad Borowski14年

67

C,33个字节

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

19
2014年的素数分解需要ASCII 5真令人讨厌!
本杰克逊

我得到了(int a; YES; a ++){NSLog(@“%i”,a);} for Cocoa Touch目标C,但是我还不能添加(评级不够)。它的确显示了2014年的最终版本,并且出现了编译器错误,并且可能根本无法正常工作,并且编译后的时间可能约为4.2兆-但是,嘿。
再生钢

main(){printf(“%d”,'\ a \ xde');}
mjy 2014年

1
@mjy不保证多字符文字的字节顺序。
Jonathon Reinhart 2014年

@JonathonReinhart多字符文字完全是实现定义的。
2015年

54

Mathematica,14个字符(如果将位图算作一个字符,则为15个字符)

TextRecognize @在此处输入图片说明


50
实际上,您应该计算字节数,使其为14 +位图图像的大小。
Sylwester'1

22
实际上,位图可能是7,357个字符。
Joe Z.

5
另外,我相信图像中的某些字节属于该\d范围。也就是说,如果它是GIF,则标头本身一定会包含一些。
John Dvorak 2014年

13
你们都是杀人鬼。很好,使用First @ ToCharacterCode @“ߞ”表示25个字符,26个字节。
2014年

9
另外,这是一个30个字符的Mathematica解决方案--URLFetch @“ goo.gl/miVwHe
Michael Stern

53

Python3.4.0b2(0个字节)

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

一旦人们从现在开始每年更新他们的Python 3版本,这将无法正常工作。
Joe Z. 2014年

21
这就是为什么我提到python3.4.0b2,它不会发生两次。它的发布日期,而不是系统日期。
您2014年

6
这让我微笑!
马特·弗莱彻

2
在Python 3.4.2中也可以使用。
暴民埃里克(Erik the Outgolfer)

不允许添加无关的输出。
MilkyWay90

48

Javascript,23个字节

使用Base 64转换

alert(atob("MjAxNA=="))

23个字符(仅16个字符和atob)

要么

alert("MMXIV") // ;)

27
MMXIV没有与共同的字符2014,上一次我检查了...// ;)
Joe Z.

23
古罗马人可能会不同意。不过,第一个采用现代英语制作了2014年。
2014年

1
您的第一个没有输出...
门把手

1
如果您在Chrome中打开控制台,请粘贴并点击Enter,它会返回值-无论如何,我都会向其添加一个警报,因为警报的时间要长于其他警报。
逻辑

5
@ logic8:尼斯+1。另一个JavaScript版本也可以使用:( 4个字节)[!+[]+!+[]]+[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]- alert([!+[]+!+[]]+[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]);尽管我不确定它是否符合Joe Z的要求。
Nope 2014年

41

Perl-10个字符

该解决方案由PerlMonks上的BrowserUK提供,尽管我从他发布的解决方案中删除了一些不必要的标点符号和空格。在四个字符的二进制字符串上按位“不”。

say~"ÍÏÎË"

上面显示的字符代表二进制字节cd:cf:ce:cb,并且它们在ISO-8859-1和ISO-8859-15中的显示方式。

这是十六进制的整个脚本,以及运行该脚本的示例:

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

Perl(无高位)-14个字符

say'````'^RPQT

这对两个四个字符的字符串"RPQT""````"(即四个反引号)使用按位“或” 。

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

(最初,我以相反的方式使用了两个字符串,这两个字符串之间需要有空格printRPQT以分隔标记。@ DomHastings指出,通过将它们切换来保存字符,就可以了。)

Perl(作弊)-8个字符

这可能不符合竞争精神,但是PerlMonks上的hdb指出 Perl提供了一个名为的变量$0,其中包含正在执行的当前程序的名称。如果允许我们将包含脚本的文件命名为“ 2014”,那么$0它将等于2014。$0包含一个数字,因此我们不能直接使用它,但是${...}包含一个计算结果为0的表达式就可以了;例如:

say${$|}

为了保持一致性,我们来做hexcat-then-perl事情:

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

我认为这是作弊,但这仍然是一个有趣的解决方案,因此值得一提。


2
嘿,如果你扭转字符串,裸字,你可以保存一个char: print"````"^RPQTsay在-5.10+上也可以使用-E而不是-e 来使用,但是我不知道这是否会对不同的命令行参数造成+2的损失?
Dom Hastings

2
指定您使用Perl 5 say且不加任何罚款被认为是可以接受的。
彼得·泰勒

@DomHastings,我个人认为如果您要使用“ -e”或“ -E”,那么您应该在字符数中包括整个命令,包括“ perl -E” 。
tobyink 2014年


4
您也可以使用不需要引号的字符串文字来保存另一个字节,例如say ABCD^srrp
primo 2014年

40

Ruby,20岁

p 'bbc'.to_i ?\r.ord

说明:bbc2014在基座13比Python短。不如福斯短。


23
“没有人在13基上开玩笑!”
吉恩-迈克尔Celerier

1
w =?$;“ ^ XA [_AXeMFGIAHJLjKNAEFEJJNHQHNKLAEMINJOJOHLAGKHOJOJ [AG [HQHRFJAH] IHAIGGwIIAHHGwKHAHGHrEUAGQFiGVAGQGfIPAFHKHHbJHAQII] MG = Kr \ nWaw | JWLA | JWLA | JWAL | ZW {A | J(J} =?$?'':: $$ * r)}
Darren Stone

1
p 'ߞ'.ord要获得功能齐全的程序,请'ߞ'.ord在内部irb。适用于1.9+版本
Ricardo Panaggio 2014年

1
没有“奇怪的” Unicode字符:?-*?--?\v(45 *
45-11

缩小一个字符:?.*?.-?f(46 *
46-102

29

Powershell,9

+"ߞ"[""]

ߞU + 07DE NKO LETTER KA)根据代码高尔夫标签info计为两个字节。

[""]返回字符串中的第一个字符(""转换为0)。一元加运算符(+)将字符转换为整数。



@GlitchMr,谢谢,我已经纠正了我的答案。
DankoDurbić2014年

3
['']是一个很好的技巧。我通常用过,[char]但确实要短一些:)
Joey

27

Scala REPL-6个字符

"?="##

##是Scala的符号含义hashCode,Java字符串"?="散列到2014年。)

Scala REPL-4个字符,5个字节

+'ߞ'

我们最喜欢的Unicode字符上的数学运算会产生一个Int


27

Javascript,18个字符

alert(btoa('ÛMx'))

更新:在ES6中,使用模板文字可以节省两个字符:

alert(btoaMx`)

记住,上面的代码很容易理解,btoa可以根据一组明确定义的规则(RFC 4648)将一个字符串转换为另一个字符串。为了查看转换的工作方式,我们将输入字符串“ÛMx”编写为二进制数字序列,其中每个字符均以其8位字符代码表示。

输入字符 Û| M | X
字符代码(十进制)| 219 | 77 | 120
字符代码(二进制)| 11011011 | 01001101 | 01111000

在以6组为一组的最后一行中重新组织了二进制数字之后,我们得到了4个新数字的二进制表示形式,对应于字符串“ 2014”中4个字符的Base64索引。

Base64索引(二进制)| 110110 | 110100 | 110101 | 111000
Base64索引(十进制)| 54 | 52 | 53 | 56
输出字符 2 | 0 | 1 | 4

根据HTML规范,可以根据此表从其Base64索引中检索输出字符:http : //dev.w3.org/html5/spec-LC/webappapis.html#base64-table

如果您不关心细节,则可以让浏览器为您进行计算,然后发现“ÛMx”是atob('2014')用Javascript 计算的结果。


问题提到了打印号码。我知道在控制台中进行评估会导致返回结果,但通常在Code Golf上,JS答案将包含某种形式的IO(alert最常见)。
zzzzBov 2014年

@zzzzBov是的,我的原始答案包括一个alert电话。
GOTO

它列出了社区已删除alert。我想知道JS codegolf的标准是否已更改,或者仅仅是社区采用的更改。
zzzzBov 2014年

@zzzzBov:这是SHiNKiROU和luser droog接受的匿名用户所做的更改。无论如何,此编辑引发了有关Meta的讨论(meta.codegolf.stackexchange.com/questions/803/…)。
Konrad Borowski

@xfix,并不是仅此编辑引起我在meta上问这个问题,我已经看到足够多的代码,人们对开发控制台是否算作打印存在意见分歧,我认为值得提出一个标准。
zzzzBov 2014年


21

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

如何只"%x"'b'*'S'?那是8212年12月或2014年的十六进制。在格式字符串上保存一个字符一个字面量和两个字符。
MSalters 2014年

@MSalters不,'b'*'S'是8134。8212的素数分解是2 * 2 * 2053,所以我看不到一种简单的生产方法。
fredoverflow

Bah,用整数除法检查到8212/'b' == 'S':(
MSalters 2014年

并且八进制也不起作用(02014 = 1036 = 37 * 28,28无法打印)
MSalters 2014年

1
@FredOverflow我的28个字符的解决方案怎么样?main(){puts(__ DATE __ +'\ a');}
Arunprasad Rajkumar


20

GolfScript,14岁

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

工作原理:ASCII如下所示:

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

因此,这将采用每个字符的ASCII码,减去五个,然后将其粘贴在字符串中。

{...}%给定字符串作为参数时,将生成映射字符串的字符数组。因此,它将每个字符增加5()意味着增加)。


所述+在端部是不必要的。另外,不要增加5次,而只需增加5次。总共节省:4个字符。'-+,/'{5+}%
贾斯汀

15
@Quincunx 5是一个数字。
彼得·泰勒

5
@PeterTaylor我一直忘记。
贾斯汀

聪明的解决方案
Sumurai14 2014年

的CJam版本:"-+,/"_,)f+。:)(然后,CJam再来一次KD。)
Martin Ender

19

Python,32个字符

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

可能有可能使用2014 th Unicode char来减少它ߞ,但是我没有尝试。

Quincunx指出

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

比三个字符短。


unicode版本至少在具有IDLE:的Python 3中有效print(ord("ߞ"))。它似乎在Python 2中不起作用。Python 2可能不支持unicode。
贾斯汀

3
另外,对于您的版本,a=ord('.');print(a*a-ord('f'))要短2个字符。
贾斯汀

@Quincunx它确实支持,但是您需要为文件设置特定的编码并将其附加u在字符串的末尾(可能是"ߞ"u
Kroltan'1

2
@Kroltan实际上,我很确定第二部分不正确。在Python 2中,您必须在字符串前加上字符串u以表示它们是unicode,但在Python 3中,所有字符串都将自动
变为

1
与上面评论的相似,没有unicode的print ord('.')**2-ord('f')时间略短。
MLS 2014年

18

APL(6个字节,4个字符)

⊃⎕TS

不过仅今年有效。

工作原理:

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

不依赖系统日期,它是10个字节(7个字符):

⎕UCS'ߞ'

6
不幸的是,仅在今年有效的答案无效。
Joe Z.

我不知道APL:那个方形框是APL字符,还是我缺少字体表示(Chrome)?
2014年

@JoeZ .:问题不是这样,但是我添加了一个不依赖它的2014
。– marinus

4
@CarlWitthoft:它被称为四边形(),应该看起来像这样。
marinus 2014年

18

Python 32 10字节,91 85(math默认情况下为66 )是纯数学字节

编写这个过程很有趣:

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)

打印出我可以2014使用Bruno Le Floch的方法(32个字符)编写的所有可能方式:

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

但这显然是多余的,因此,如果您的解释器默认情况下设置为utf-8,则只需执行以下操作:

>>> ord(u'ߞ')
2014

另外,由于有了AmeliaBR(这个想法),我尽力实现了纯数学版本:

from math import*
a,b,c=int(e),round(e),ceil(pi);print int(a**(b*c-(c-b))-a*a**c-a)

ord(',')** 2 + ord('N')
MLS

6
@MLS好吧,里面有一个数字:)
Joachim Isaksson

2
我对数学版本进行了一些优化:a,b=int(e),int(pi);c=a+a;print a**(b*c-c+b)-a*a**c-a,您可以利用TruePython 2.x在操作中与整数1相同,将其减少到50个字符这一事实,完全消除数学导入:o=True;a=o+o;b=a+o;c=b+o;print a**(b*c-o)-a*a**c-a
Ponkadoodle

如果使用Python 3,则可以保存字符:ord('ߞ')
asmeurer 2014年

@JoachimIsaksson一个数字是没有数字;)
Mega Man

17

R(20个字符)

@popojan(尚未允许他在此处发布答案)提供了20个字符以内的解决方案。

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

输出:

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

R(22个字符)

匿名用户建议了较短的解决方案。

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

2014BBC在基座13 pi*pi+pi(= 13.0112)由R在这种情况下作为所述整数13输出处理过的:

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

R(30个字符)

感谢@Tomas!

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

输出:

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

R(31个字符)

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

AmeliaBR的答案中得到启发。输出:

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

哇,+ 1!我希望我的罗马数字解决方案是最好的... :( ;-)
Tomas

以下变体可以更短一些:cat(a<-T+T,T-T,T/T,a^a,sep="")(30个字符),paste0(aT+T,T-T,T/T,a^a)(26个字符)
Tomas

@Tomas,paste0不允许该函数,因为它包含符号0。如果使用,您的解决方案将使用30个字符cat
djhurio 2014年

2014在当前目录中创建文件并写入list.files()-12个字符
Zbynek 2014年

@Zbynek,我希望您的解决方案在codegolf规则的一般范围内无效。
djhurio

15

Java- 77 75个字符

如果print使用main方法在类中添加了75个字符:

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

这意味着35*60-86等于2014


2
我喜欢你的配方。
约翰内斯

7
实际上,这需要更长的时间,因为需要在其中运行类定义。我知道的最短方式(使用Java 6):class a{static{System.out.println('#'*'<'-'V');}}
Justin

1
@Quincunx,对于Java 7,需要一种主要方法
True Soft

2
@TrueSoft注意,我说“使用Java 6”。您应该选择最短的Java。
贾斯汀

2
您可以在println中删除'ln'以减少字符...
laksys 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.