任务

所有竞争对手都试图解决以下10个任务列表：

数学

1. 从输入中读取正整数n并返回前n个非负整数的立方和。

   对于输入1，应该返回0。

2. 当且仅当n是梅森素数时，才从输入读取正整数n并返回真实值。

3. 从输入读取n个整数的非空列表，并返回它们的中值。

   如果n为偶数，则使用两个中间值中的较小者。

   例如，的中位数[1 4 3 2]为2。

4. 从输入中读取整数（正，负或0）或以10为底或一进制的字符串表示形式，并以negabinary返回其数字，且不带前导零（输入0除外）。

   可以用任何方便的方式（数字，数组，字符串等）格式化输出。

串

5. 返回pneumonoultramicroscopicsilicovolcanoconiosis。

6. 检查当前日期，并Happy New Year!根据公历返回合适的日期。

7. 伪随机地从Unicode块CJK Unified Ideographs Extension-A（U + 3400 – U + 4DB5）中选择64个唯一分配的代码点，然后返回相应字符的字符串。

   所有可能的字符串应具有相同的被选择概率。

8. 当且仅当第一个字符串的字符形成第二个字符串的子序列时，才从输入中读取两个可打印的ASCII字符串，并返回真实值。

   例如，abc，axbxc应该返回truthy和bac，axbxc应该返回falsy。

数组操作

9. 从输入中读取一个多维的矩形整数数组和一个整数n，并返回修改后的数组，其中所有整数均乘以n。

艺术

10. 从输入中读取一个非负整数n，并返回n个火车货车的链，如下所示。

    n = 3的示例输出：

     ______   ______   ______ 
    |      | |      | |      |
     ()--() ~ ()--() ~ ()--()
    

    只要示例中的输出看起来可以被任意数量的空格包围。

澄清说明

• 0既不是正数也不是负数。

• 在输出中始终允许尾随空格。

• 可以以任何一致，方便的顺序读取几条输入。

规则

1. 没有答案可以用相同的编程语言解决两个不同的任务。^1个

2. 对于每个单独的任务，均适用标准代码高尔夫球规则。

   特别是，您可以使用通常的I / O默认值提交程序或函数，但不能利用这些漏洞。

   任务5本质上是一个kolmogorov复杂性挑战，因此，不仅允许输出硬编码，而且可以预期输出硬编码。

3. 每个用户只能发布一个答案，其中最多包含每个任务的一种解决方案。

   请按照以下示例中的格式设置答案：

   ## Task 1, Python, 42 bytes
   
       <code goes here>
   
   Explanation, I/O, required Python version, etc. go here.
   
   ---
   
   ## Task 7, C, 42 bytes
   
       <code goes here>
   
   Explanation, I/O, required compiler (flags), etc. go here.
   

计分

1. 对于您解决的每一项任务，您都会得到一分。

   这意味着您不必解决所有任务即可参与。

2. 如果您针对任务n的解决方案是该编程语言中最短的解决方案，那么您将获得额外的好处。

3. 如果您对任务n的解决方案是所有编程语言中最短的一种，那么您将获得额外的好处。

4. 每个任务语言组合和每个任务分别仅奖励一次奖励积分。

   通常，如果两个解决方案具有相同的字节数，则发帖时间是平局。

   如果以后有人超过您，您将失去其他答题者获得的奖励积分。

5. 您可以进行高尔夫投稿，从答案中添加/删除语言，或交换用于两项任务的语言。

   每当有人编辑他的答案时，所有答案都会重新记录。

6. 一旦您更改了任务的语言，就失去了资历。²

得分最高的答案将获胜。³

每任务排行榜

<style>body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}</style><script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><table class=answer-list><thead><tr><td>Task<td>Author<td>Language<td>Score<tbody id=answers></table></div><table style=display:none><tbody id=answer-template><tr><td>{{TASK}}<td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}</table><script>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 getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function process(){answers.forEach(function(e){var s=e.body_markdown.split("\n").filter(function(e){return"#"==e[0]});s.forEach(function(s){var r=s.match(NUMBER_REG)[0],t=(s.match(SIZE_REG)||[0])[0],a=s.match(LANGUAGE_REG)[1],n=e.owner.display_name;entries.push({task:r,user:n,language:a,size:t})})}),entries.sort(function(e,s){var r=e.task-s.task;return r?r:e.size-s.size});for(var e=0;e<entries.length;e++){var s=jQuery("#answer-template").html();s=s.replace("{{TASK}}",entries[e].task).replace("{{NAME}}",entries[e].user).replace("{{LANGUAGE}}",entries[e].language).replace("{{SIZE}}",entries[e].size),s=jQuery(s),jQuery("#answers").append(s)}}var QUESTION_ID=52152,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*.*?,\s*\[*([^,\]]+)/,entries=[];</script>

联合排行榜（2015-07-30 20:00 UTC）

User / Task      1 2 3 4 5 6 7 8 9 A   TOTAL   Tie breaker (if any)

DLosc            2 2 3 2 2 2 2 3 2 2      22
Sp3000           2 2 2 2 2 3 2 2 2 2      21
Doorknob         2 2 2 2 2 2 2 2 2 2      20
mathmandan       2 2 2 2 2 2 2 2 2 2      20   Combined byte count.
MickyT           2 2 2 2 2 2 1 2 2 2      19
Alex A.          2 1 2 2 2 2 1 2 2 2      18
Jacob            2 2 2 2 2 1 0 0 0 2      13
alephalpha       2 2 2 0 2 2 0 0 2 0      12
Martin Büttner   2 0 0 2 2 0 0 2 2 2      12   Combined byte count.
kirbyfan64sos    1 2 2 0 2 X 0 2 0 3      12   Per-language wins.
Maltysen         3 0 0 0 3 2 1 X 2 0      11
plannapus        2 2 0 0 2 2 0 2 0 2      10
jimmy23013       0 0 2 3 0 0 3 2 0 0      10   Solved tasks.
Tom              0 3 0 0 2 2 0 X 3 0      10   Combined byte count.
FryAmTheEggman   1 0 2 0 2 0 2 0 2 0       9
Vioz-            1 0 2 2 2 2 0 0 0 0       9   Combined byte count.
Toby Speight     2 0 0 0 2 2 0 0 0 2       8
Ismael Miguel    0 0 0 0 2 2 0 0 0 2       6
Pulga            0 2 2 0 0 0 0 0 0 2       6   Combined byte count.
flawr            2 0 2 0 0 0 0 0 0 0       4     
manatwork        2 0 0 0 0 2 0 0 0 0       4   Combined byte count.
TheNumberOne     1 0 0 0 2 0 0 0 0 0       3

标X有的任务存在但无效。

组合排行榜是手工建造的。请告诉我是否有任何错误。

¹ _{如果语言不是相同语言的不同版本，则它们被视为不同语言，因此只有一种JavaScript，一种Python和一种TI-BASIC，但是C，C ++，Octave和MATLAB是四种不同的语言。}

² _{如果你解决任务ñ使用的语言大号的X个字节，别人解决了使用相同的字节数相同的语言相同的任务，您更改语言中号和回滚的编辑，其他的回答者将保持奖励积分。}

³ _{从计分规则1、2和3（按此顺序）获得的点数，所有已解决任务的组合字节数（越低越好），最后，选票统计（越高越好）可作为决胜局。}

任务1，GolfScript，8个字节

~,{+}*.*

与Martin的CJam答案相同。

任务2，QBasic，74 71字节

INPUT a
r=a>1
FOR i=2 TO a-1
r=r*(a MOD i)
NEXT
?r*((a\2AND a)=a\2)

在QB64上测试，语法扩展已关闭。¹该程序的大部分程序a通过对a每个数字2 <= i< 取mod a并将结果相乘来测试给定数字是否为质数。r如果数字不是素数，则结果为0，否则为非零。最后一行使用按位AND除以2的整数来检查的二进制表示形式a是否全部为1，即a形式是否为2 ⁿ -1。r如果数字不是梅森素数，则将其乘以0（假），否则乘以某个非零（真实）值。?是的快捷方式PRINT。

我测试的最大Mersenne质数8191给出的结果- 1.#INF仍然是事实！（我检查了IF一下以确保。）

¹ _{这不会改变程序的语义。如果您将上述代码键入标准DOS QBasic，它将自动格式化为多余的空格，但是它将完全相同地运行。}

任务3，Pyth，6个字节

ehc2SQ

从stdin读取Python样式的列表。这里的主要魔术是c跳跃运算符：给定一个int和一个列表，它将列表分成n个部分。因此，c2SQ将排序后的输入列表切成两半。方便地，当长度为奇数时，前半部分是较大的，因此中位数始终是前半部分的最后一个元素。这是e对的第二h印章结果的元首。

任务4，CJam，26个字节

ri{_2%z\_0>\-2/_3$+?}h;]W%

我怀疑这可以缩短。

算法：

• 读取整数。
• 在值不为0时执行：
  • 采取腹肌（i％2）。这是下一位数字（负数？）。
  • 将我除以-2。
  • 如果i是非正数，则将abs（i％2）添加到结果中。这是为了纠正特殊情况：3变为-1，但-3应该变为2，而不是1。
• 删除多余的0，将堆栈收集到一个数组中，反转并打印。

这是一个do-while循环这一事实处理了0情况。

任务5，Bash，50个字节

echo pneumonoultramicroscopicsilicovolcanoconiosis

没有太多解释。

任务6，Python，78个字节

from datetime import*
d=date.today()
if d.day<2>d.month:print"Happy New Year!"

需要Python2。在这里可以很好地利用Python的链式不等式运算符。

任务7，ActionScript，82个字节

x=""
while(x.length<64){c=chr(13312+random(6582));if(x.indexOf(c)<0)x+=c}
trace(x)

ActionScript是ECMAScript系列的成员。此代码需要ActionScript 2-对于代码高尔夫来说要好得多，因为我可以使用不推荐使用的函数，chr而不是版本3的String.fromCharCode！

输出到控制台窗格：

任务8，点子，9 19字节

正则表达式解决方案工作不完全，因此这里有一个使用字符串操作的解决方案。

Fcab@>:o&:(b@?c)+1o

Github Pip仓库。

将两个字符串作为命令行参数。当a是子序列时，输出一个正整数（真）。否则，结果为nil（falsy），不产生任何输出。

说明：

                     Cmdline args -> a,b; o = 1 (implicit)
Fca                  For each character in a:
           b@?c      Find character's index in b (nil if not found)
          (    )+1   Add 1; all possible indices except nil are now truthy
       o&:           Logical AND with o
   b@>:              Slice b to everything at index o and afterward (Python b=b[o:])
                     (If c wasn't found, b becomes nil, but we don't care at that point)
                  o  Auto-print o

任务9，Prolog（SWI），68个字节

m(L,N,R):-L=[H|T],m(H,N,I),m(T,N,U),R=[I|U];L=[],R=[];R is L*N.

Prolog通常在代码高尔夫方面根本没有竞争力，因此我对该解决方案感到非常满意。

定义谓词 m，其谓词具有L列表的输入参数以及Nnumber和output参数R。的定义m是三重析取式：

• 如果L能统一使用[H|T]，它是在它至少一个项目的清单。调用m递归上链表的头和尾，并再次把结果汇集成这是统一的一个新的列表R。
• 如果L可以与统一[]，统一R用[]为好。
• 否则，L假定为数字。L*N计算并分配给R。

swipl在Ubuntu上运行的示例：

dlosc@dlosc:~/golf$ swipl -qs arrayMult.prolog
?- m([1,2,3],5,R).
R = [5, 10, 15] .

?- m([[3,4],[5,6]],3,R).
R = [[9, 12], [15, 18]] .

?- m([[[1,2],[3,4]],[[5,6],[7,8]]],2,R).
R = [[[2, 4], [6, 8]], [[10, 12], [14, 16]]] .

任务10，C，114个 112 106字节

#define F;printf("\n");for(i=0;i<c;i++)printf(
i;t(c){F" ______  ")F"|      | ")F" ()--() ~");putchar(8);}

gcc在Ubuntu上进行了测试。定义一个t接受整数参数的函数。使用三个for循环来输出，通过宏滥用大大压缩了。使用退格字符擦除尾随会~导致相当奇怪的空格模式，但是The output may be surrounded by any amount of whitespace as long as it looks like in the example.

运行示例t(3)：

dlosc@dlosc:~/golf$ ./a.out

 ______   ______   ______
|      | |      | |      |
 ()--() ~ ()--() ~ ()--() dlosc@dlosc:~/golf$

Huzzah，首先要完成所有任务！\ o /

任务1，Perl，32字节

$_=eval join"+",map$_**3,0..$_-1

+1字节的-p标志。评论：Perl很奇怪。

任务2，CJam，14个字节

{_mp\)2mL_i=&}

我的第一个CJam程序！

任务3，GolfScript，8个字节

~$.,(2/=

评估STDIN输入，排序，取长度，减，除以2，然后在该索引处取排序数组的项。

任务4，Python，77个字节

def f(i,d=''):
 while i:i,r=i/-2,i%2;i+=r<0;r+=2*(r<0);d=`r`+d
 return d or 0

感谢@ mbomb007削减24（！）个字节，并感谢@ Sp3000减少11个字节。

任务5，Java，66个字节

String f(){return"pneumonoultramicroscopicsilicovolcanoconiosis";}

无聊 在此处剔除冗长的语言，以便稍后为高尔夫球手使用的语言留出空间。

任务6，Bash，39个字节

((`date +%j`<2))&&echo Happy New Year\!

感谢@manatwork教给我有关知识%j，在此过程中节省了10个字节。

任务7，JavaScript，148字节

a=[];Array(65).join('x').replace(/./g,function(){while(a.push(s=String.fromCharCode(13312+Math.random()*6582))&&a.indexOf(s)==s.length-1);return s})

生成一个由64组成的字符串x，然后将其全部替换为一个回调函数，该函数将返回一个随机的字符（如果尚未在使用的字符数组中返回）。

任务8，Rust，130个字节

fn f(a:String,b:String)->bool{let mut c=b.chars();for x in a.chars(){match c.find(|&y|x==y){Some(_)=>(),None=>return false}};true}

是的，Rust非常擅长打高尔夫球。

任务9，鸵鸟，18个字节

{:n;'`\d+`{~n*}X~}

版本0.7.0。检查数组，是否进行正则表达式替换以将数字更改为其相乘的版本，然后再次评估结果字符串。

任务10，Ruby，58个字节

->n{([' ______  '*n,'|      | '*n,' ()--() ~'*n]*$/).chop}

"\n"比的长度多"{actual newline}"一个字符，比的长度多一个字符$/。感谢@MartinBüttner用黑魔法的各种技巧削减了{不确定但大量的}字节。

任务1，3var，14 13字节

'><k*>#aa/>sp

（3var的Esolang Wiki页面）

'                  R = n
 >                 A = n
  <k               B = n-1
    *              R = A*B = n(n-1)
     >             A = n(n-1)
      #aa          B = 2
         /         R = A/B = n(n-1)/2
          >s       A = (n(n-1)/2)^2
            p      Output A

通过代码点进行输入，例如空格为32。

值得庆幸的是，我们需要执行该公式的所有操作n^2 (n-1)^2 / 4都是单个字符（减量，乘法和平方），但是将其设置B为2 需要3个字节（reset-increment-increment）。

任务2，Retina，38 33字节

^
1
^(..|.(..+)\2+|(.(..)+)\3*)$
<empty>

（视网膜的Github存储库）

每行都在一个单独的文件中，但是您可以使用该-s标志按原样测试上面的内容（不替换<empty>任何内容）。输入应为1进制的一进制，例如11111117。

这是每个正则表达式替换（由两行指定）的作用：

1. 在前面附加1
2. 替换任何形式的2，1 + composite或not power of 2不替换任何内容。

这1为Mersenne素数增加了一个额外的数字，而其他所有数字都被消除了。

任务3，球拍，71字节

#lang racket
(define(m x)(list-ref(sort x <)(quotient(-(length x)1)2)))

类似Lisp的语言过于罗word。示例运行：

> (m `(1 3 4 2))
2

任务4，> <>，​​31个字节

:?!v:2%:@-02-,
)?~\l1
!;n>l?

（Esolang Wiki页面的> <>）

上面是28个字节，并且需要-vPython解释器中的该标志另外3个字节，例如，运行类似

$ py -3 fish.py negabinary.fish -v -137
10001011

关于> <>的好处是，我们可以通过取模和除法来一一计算数字，从而得出相反的顺序，非常适合打印堆栈。

任务5，括号，1448 1386字节

((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))((()(()))((()()())((())()()()()))((()()())((())()()))((()()()())((())()()()()))((()()())((())()()()()()()()()()))((()()())((())()))((()()())((())()()()))((()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()))((()()())((())))((()()())((())()()()()()()()()))((()()())((())()()()()()()))((()()()())((())))((()()())((())()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()()))((()()())((())()()()))((()()())((())))((()()()())((())()()))((()()()())((())))((()()())((())()()))((()()())((())()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()))((()()()())((())()()()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())()()()()()()())))

（Github括号库）

我对此有一个CJam答案，它比字符串本身短，但是我不能使用它，所以我想我会选择其他方式。

Python 3生成代码：

char97 = "((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))"
char108 = "((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))"
open_str = "((()(()))"
close_str = ")"

target = "pneumonoultramicroscopicsilicovolcanoconiosis"
output = [char97, char108, open_str]

for c in target:
    if ord(c) >= 108:
        output.append("((()()())((())%s))"%("()"*(ord(c)-108)))
    else:
        output.append("((()()()())((())%s))"%("()"*(ord(c)-97)))

output.append(close_str)
print("".join(output))

这是相应的类似Lisp的代码：

(define f (lambda (n) (char (+ n 97))))
(define g (lambda (n) (f (+ n 11))))

(+
   (g 4)  // p
   (g 2)  // n
   (f 4)  // e
   ...
)

显然可以将其define命名g为()()，这样可以节省很多字节。

任务6，CJam，26个字节

XY]et1>>"Happy New Year!"*

检查[month day]本地时间数组的一部分是否小于[1, 2]。

任务7，Python，73个字节

from random import*
print(*map(chr,sample(range(13312,19894),64)),sep="")

只是一个简单的Python 3实现。

任务8，序曲，46 41字节

?(?)#(#)?(v-(#)?)10)!
      ^      1 # (0

（Esolang Wiki页面的Prelude）

我认为这很有效–可能仍然可以打高尔夫球，但这是我第一次在Prelude中进行不平凡的高尔夫。输入格式<needle>NUL<haystack>，其中NUL是0x00。这NUMERIC_OUTPUT = True在Python解释器中效果最好，因为这将使其输出1或0适当输出。

我选择Prelude是因为有两个属性使它非常适合此任务：

• 它是基于堆栈的，因此您可以先读入针，然后一次处理干草堆一个字符，然后
• Prelude的堆栈底部有无限个0，因此您无需处理指针用完字符的情况。

如果Prelude具有NOT运算符，则效果会更好。

细目如下：

?(?)#    Read input up to the NUL, discarding the NUL afterwards

(#)      Move the needle to the second voice, effectively reversing the stack
 ^

?(...?)  Read haystack

  v-     Compare top needle char with haystack char by subtraction

  (#)    If equal, pop the needle char
   1 #

10)!     Output 1 if the top needle char is 0 (bottom of stack), 0 otherwise
(0

（-5个字节，感谢@MartinBüttner）

任务9，Mathematica，4个字节

#2#&

诸如此类的东西2 {{0, 1}, {1, 0}}在Mathematica中是隐式乘法，因此这只是将参数并排放置。

正如@MartinButtner和@alephalpha所指出的，1##&另一个答案是4字节。参见前者的解释。

任务10，铁路，246个 237字节

$'main'
 0/aima19-@
@------e<
         -(!!)()[ ][ ______ ]{f}[\n\]o()[ ][|      |]{f}[\n\]o()[~][ ()--() ]{f}#
$'f'                 #           #
 -(!x!)(!y!)(!!)()0g<  -(x)o()1g<  -(y)o()1s(y)(x){f}#
                     -/          -/

（Esolang Wiki的Wiki页面）

我不能错过在Rail中完成与火车相关的任务的机会：）空白看上去很容易打高尔夫球，但是如果分支需要占用三行，则需要花费一些时间进行压缩。

通过STDIN输入的是整数，但必须有一个EOF。左上方

 0/aima19-@
@------e<

是一个atoi循环，它将输入转换为整数，而不是EOF（由e指令检查）。

f最后三行的函数采用x, y, n，并输出字符串x n时间，以分隔y。该函数是递归的，n每次递减一，直到它变为零。f被调用三次，为每一行提供不同的字符串。奇怪的是，Rail允许变量名为空，从而节省了一些字节。

不幸的是(!x!)，大多数字节来自，它弹出堆栈的顶部并将其分配给variable x和(x)，然后将x其压入堆栈。这是必要的，因为Rail中没有重复的运算符，所以这(!x!)(x)(x)是复制堆栈顶部的唯一方法。

任务1，CJam，7个字节

q~,:+_*

我只是想为此获得（大概）最佳CJam解决方案。它利用了以下事实：前n个立方体的总和是第n 个三角数的平方，它本身就是前n个整数的总和。

在这里测试。

任务4，裂变，173 88 78 69 68字节

Fission的GitHub存储库。

 /@\O/S@+>\
^{ }[<X/ @/;
,\?/@\J^X\
'M~\$ $
UK/W%@]  /
D
?\{\/
0'A Y

我的第二个相当复杂的裂变程序。:)

输入格式有点奇怪。为了支持负输入，第一个字符应为+或-表示符号。第二个字符的字节值就是输入的大小（因为Fission不能本地读取十进制整数）。因此，如果您希望111将其+o通过STDIN。如果你想要-56通过的话-8。您可以分别使用具有较低或较高字符代码的任何字符来代替+和-。传递类似-n（您echo可能将其视为自变量）的内容（例如）可能会很有帮助0n。

让我们看一下如何找到正数的负表示。我们要计算从最小到最高有效位的数量（将这些位压入堆栈，并在最后打印它们，以正确的顺序排列它们）。然后，第一个数字就是数字的奇偶校验，我们将数字除以2即可继续处理。下一位数字现在为负（值为-2）-但应注意的是，每当将2位设置为普通二进制数时，该位就会被设置。唯一的区别是，我们需要用正的较高值的数字来抵消-2。所以我们要做的是：

• 我们再次确定奇偶校验-这是下一个纳比特-和以前一样除以2。
• 如果该数字是a 1，我们将剩余的数字加1以抵消负数位（负数位和一位之间的差是下一个更高位的值一次）。

注意，在此处有条件地加一个等于在整数除法时将数字向上舍入（如果舍弃的位为1，则将整数除法的结果加1）会极大地简化代码。

然后，下一位再次只是一个正值，因此我们可以正常确定它。这意味着我们想要一个循环一次计算两位的循环，在剩余数字的向上舍入和向下舍入之间交替，但是我们想在中间进入循环，因此我们从向下舍入开始。

我们如何处理负整数？问题在于，裂变实际上不能对负整数进行任意算术，因为质量总是非负的。因此，人们将不得不做一些非常复杂的事情，例如处理幅度并在其他地方跟踪符号。但是，可以基于相关的正数来计算负数的负表示：

如果Ñ是否定的，计算的negabinary表示的n / 2（四舍五入向上）和附加的奇偶Ñ。

这正是我们两位循环的第一步。因此，我们要做的就是如果符号为负，则从另一个点开始循环。

从173个原始字节中节省的大部分钱来自这些见解，这些见解使我可以将三个奇偶校验和一个两节循环压缩为一个具有单个奇偶校验的循环。

如果我详细解释所有代码，那么这篇文章会太长，但是我将指出一些部分来给出控制流的粗略布局，并且您可以使用Fission参考来弄清楚这些细节。

 /@\
^{ }[
,\?/
'
U
D
?

从开始D，这将读入一个符号位，该符号位进入该能量的量级，并将大小读入一个原子，该原子最终位于[（向右移动）。每次通过奇偶校验后，该符号位将交替出现，并将确定我们保留循环输入的四舍五入还是四舍五入。

     /S@+>\
    [<X/ @/
 \  @\J^X\
 M  $ $
 K  %@]  /

这是一个计算各个位并将正确的一半送入下一个迭代的循环。在S和J用于创建基于当前的符号位的右半部分的复印件，X就做了复制。的>在右上角计算，然后将其发送到所述堆叠中的实际比特K稍后检索。我认为右上角的布局非常漂亮，如果您对Fission感兴趣，那么绝对值得详细研究。

的%是，只要它大于0馈送数回环的开关。

    O


 M~\
 K/W%

 \{\/
0'A Y

一旦数字达到0，它就会向下反映。这将启动另一个循环，该循环从堆栈中检索位，将其添加到的字符代码中0并使用进行打印O。一旦堆栈为空，程序将终止，因为控制原子最终将被推到堆栈上（此后不再有移动的原子了）。

任务5，前奏，219个 179 96字节

前奏的Esolangs页面。

适用于Prelude的Stack Snippet解释程序。

29+129+716705-7607-05-4759+705-14129+05-18705-29+719+05-1507-19+39+449+767549+03-68(67+^+^+^++!)

它最初是一个标准的手工制作的固定输出的Prelude程序，带有三个声音。与Sp3000聊天后，我决定尝试使用单个声音。原来，这很好用，因为重用旧字母要容易得多。然后丹尼斯给了我一些提示，我找到了当前版本：想法是将字母的所有偏移量h以相反的顺序推入单个语音的堆栈中，然后一次循环打印一次。h之所以选择，是因为h字符串中没有（这很重要-否则，0偏移将终止循环），并且因为它会以两位数和负偏移量最小化偏移的编码。

偏移编码是使用此CJam脚本生成的。

任务8，Mathematica，28个字节

LongestCommonSequence@##==#&

是的，内置的。（Mathematica的命名在这里有点怪异... LongestCommonSubsequence找到最长的公共子串，而LongestCommonSequence找到最长的公共子序列。）

任务9，J，1个字节

*

与APL和K的答案相同，但似乎还没有人选择J。

任务10，视网膜，67 60字节

视网膜的GitHub存储库。

(.*).
 ______  $1<LF>|      | $1<LF> ()--() ~$1
+`(.{9})1
$1$1
~$
<empty>

每行都在一个单独的文件中，并且<LF>应该用换行符替换，并且<empty>应该是一个空文件。您也可以将所有这些都放在一个文件中，并使用该-s选项，但是这不允许在其中插入换行符<LF>。您可以通过做类似的事情来模仿

echo -n "111" | ./Retina -s train.ret | ./Retina -e "<LF>" -e "\n"

如以上示例所示，输入应该是一元的。该代码的想法是创建一元输入的三个副本（减1），每个副本都有对应行的副本。然后，我们重复复制a前面的最后九个字符，1直到所有1s都消失了，从而根据需要重复行。最后，我们删除了多余的尾随~。

嗯，我先从一对夫妇开始。第一次打高尔夫球。

任务1，Python，38个 21字节

lambda n:(n*n-n)**2/4

汇总所有多维数据集的列表，最多x个。借助xnor更改了表达式

任务2，TI-Basic 89，244字节

Func
If iPart(log(x+1)/log(2))=log(x+1)/log(2) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc
Func
If isPrime(x)=false
 Return 0
If ipart(log(x+1)/log(2))=log(log(x+1)/log(2)) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc

当我为计算器找到新电池时，不能百分百确定这一点。isPrime是内置函数，ipart是整数部分（2.3-> 2）

任务3，Perl，45 34字节

@n=sort{$a-$b}@ARGV;print$n[$#n/2]

perl文件1 2 3 4-> 2.感谢@nutki，节省了几个字节。打印而不是保存到变量然后打印变量。

任务4，Ruby，43个 40字节

x=2863311530
p ((gets.to_i+x)^x).to_s(2)

至少它可以在1.9中使用，而对于1.8则不知道。在二进制数中，“ 10” * 16（或2863311530）加一个数字，与10101010 ...的xor是负数。输出带引号的字符串表示形式（3->“ 111”而不是3-> 111）。找不到用更少的字符写x的数学。

任务5，Malbolge，682354字节

D'``_]>n<|49ixTfR@sbq<(^J\ljY!DVf#/yb`vu)(xwpunsrk1Rngfkd*hgfe^]#a`BA]\[TxRQVOTSLpJOHlL.DhHA@d>C<`#?>7<54X8165.R2r0/(L,%k)"F&}${zy?`_uts9Zvo5slkji/glkdcb(fed]b[!B^WVUyYXQ9UNrLKPIHl/.JCBGFE>bBA@"!7[;{z276/.R2r0)(-&J$j('~D${"y?w_utyxq7Xtmlkji/gf,MLbgf_dc\"`BA]\UyYXWP8NMLpPIHGLEiIHGF(>C<A@9]7<;:3W7w5.-210/(L,%k#('~}C{"y?`_uts9wpXn4rkpoh.lNMiha'eGF\[`_^W{h

在这里在线测试认为这将是很短的。尽我所能打高尔夫球。保存了300个字节，那么呢？

任务6，bash，62 50 40字节

[ `date +%j`=1 ]&&echo 'Happy New Year!'

从另一篇文章中找到有关％j的信息。

任务10，Befunge-98，121字节

>&:>1-:" ____"v
   |,k8: '"__"<
   >a,$:>1-v
      > |
>' 8k,^ #
^|':k4 '|':<
v ',*25$<
>,:1-: ")(--)("v
^," ~"_@#,k6" "<

更改为befunge-98。年纪Befunge-93，227个157 147字节。用Haskell编写的二手真菌进行测试。使用“多次执行k”，并使用'将单个字符添加到堆栈中。我感觉它可以打到110或更少，但是我已经花了太多时间在此上。

第一件事：任务6在技术上确实不计; 我在一小时前上传了unc。但是，今天早上我几乎上传了它，但决定首先编写一个测试套件。白痴。

所以，无论如何，这就是去！

请注意，大多数unc事情都是有意向后的，所以&&实际上是||这样的，这就是为什么某些操作看起来很奇怪的原因（例如，-用于计算多维数据集）。

任务1，Haskell，21个字节

f n=sum$map(^3)[0..n]

任务2，Hy，135个字节

(import math)(fn[n](and(if(and(not(% n 2))(> n 2))false(all(genexpr(% n i)[i(->> n(math.sqrt)int inc(range 3))])))(->> n dec(& n)not)))

任务3，Dart，37个字节

我的第一个Dart功能！

f(l){l.sort();return l[l.length~/2];}

任务5，INTERCAL，1047字节

DO ,1 <- #46
DO ,1SUB#1 <- #242
DO ,1SUB#2 <- #152
DO ,1SUB#3 <- #208
PLEASE DO ,1SUB#4 <- #248
DO ,1SUB#5 <- #248
DO ,1SUB#6 <- #192
PLEASE DO ,1SUB#7 <- #128
DO ,1SUB#8 <- #128
DO ,1SUB#9 <- #72
PLEASE DO ,1SUB#10 <- #120
DO ,1SUB#11 <- #8
DO ,1SUB#12 <- #224
PLEASE DO ,1SUB#13 <- #200
DO ,1SUB#14 <- #208
DO ,1SUB#15 <- #32
PLEASE DO ,1SUB#16 <- #208
DO ,1SUB#17 <- #120
DO ,1SUB#18 <- #88
PLEASE DO ,1SUB#19 <- #40
DO ,1SUB#20 <- #8
DO ,1SUB#21 <- #208
PLEASE DO ,1SUB#22 <- #232
DO ,1SUB#23 <- #120
DO ,1SUB#24 <- #208
PLEASE DO ,1SUB#25 <- #248
DO ,1SUB#26 <- #56
DO ,1SUB#27 <- #96
PLEASE DO ,1SUB#28 <- #160
DO ,1SUB#29 <- #208
DO ,1SUB#30 <- #208
PLEASE DO ,1SUB#31 <- #136
DO ,1SUB#32 <- #120
DO ,1SUB#33 <- #192
PLEASE DO ,1SUB#34 <- #112
DO ,1SUB#35 <- #64
DO ,1SUB#36 <- #16
PLEASE DO ,1SUB#37 <- #128
DO ,1SUB#38 <- #48
DO ,1SUB#39 <- #208
PLEASE DO ,1SUB#40 <- #128
DO ,1SUB#41 <- #224
DO ,1SUB#42 <- #160
PLEASE DO ,1SUB#43 <- #40
DO ,1SUB#44 <- #56
DO ,1SUB#45 <- #200
PLEASE DO ,1SUB#46 <- #126
PLEASE DO READ OUT ,1
DO GIVE UP

任务6，unc，157字节

!include>=fgQVb%U<=
!include>=gVZR%U<=
false lRNe[]<<gVZR_g t:=gVZR[5]:volatile gZ m:=-YbPNYgVZR[&t]:for[#m%gZ_Zba||m%gZ_ZQNl!=6]chgf[L'uNccl ARj LRNe#']:>>

任务8，rs，42个字节

#
+#(.)(.*) .*?\1/\1#\2 
.*# .*$/1
[^1]+/0

现场演示。

任务10，Pyth，46个字节

jb(j*d2m+\ *\_6Qjdm"|      |"Qj\~m" ()--() "Q)

现场演示。

任务1，APL，7个字节

+/3*⍨⍳⎕

您可以使用ngn / apl 在线尝试它，尽管它可以与任何默认为0索引原点的APL实现一起使用。

⍳⎕通过将（⍨）自变量转换为幂运算符（*），可将0到输入（）-1之间的每个整数求立方。通过求和（+/）减少所得向量，并返回标量。

任务2，Julia，42个字节

n->(isprime(n)&&int(log2(n+1))==log2(n+1))

这将创建一个匿名函数，该函数接受整数作为输入并返回一个布尔值。要给它起个名字，例如f=n->...。

首先，我们使用Julia的内置函数isprime来检查是否n为质数。如果是，则检查log2(n+1)是否为整数。如果是这样，n则可以写成2^k-1some k，因此n是梅森素数。

任务3，ELI，19个字节

{f:x[<x][~.0.5*#x]}

这将创建一个monad f，该monad 返回输入向量的中值。

取消+说明：

{f:         // Define a function f
 x[<x]      // Sort the input vector
 [          // Select the element at index...
 ~.0.5*#x   // ceiling of 0.5 * length(input)
]}

例子：

    f 1 2 3 4
2
    f ?.!20   // Apply f to 20 random integers in 1..20
4

任务4，八度，39字节

@(n,x=2863311530)dec2bin(bitxor(n+x,x))

这将创建一个函数句柄，该函数句柄接受一个整数作为输入并返回关联的负数字符串。要调用它，请给它起一个名字，例如f=@...，然后使用运行feval(f, <input>)。

您可以在线尝试。

任务5，CJam，47个字节

"pneumonoultramicroscopicsilicovolcanoconiosis"

该字符串仅打印到STDOUT。如果您愿意，可以在线尝试。

任务6，Windows批处理，46字节

if "%date:~4,5%"=="01/01" echo Happy New Year!

变量%date%以形式包含当前日期Thu 06/25/2015。我们可以通过跳过前4个字符后获得长度为5的子字符串来选择月份和日期%date:~4,5%。从那里，我们只检查是否是1月1日，然后说“新年快乐”。

任务7，Pyth，26个字节

=Gr13312 19895FNU64pC.(.SG

首先，我们将G范围指定为13312到19894（含）。然后循环执行64次，并在每次迭代时都随机播放G（.SG），删除并返回最后一个元素（.(），然后打印其字符表示形式（pC）。

您可以在线尝试。

任务8，Ruby，36个字节

def f(a,b)!b.tr("^"+a,"")[a].nil?end

这定义了一个函数f，该函数接受两个字符串，a并且b在其中a找到该字符串b。

除了中的字符外，所有内容a都从busing 中删除.tr()，我们检查结果是否包含ausing []。nil如果找不到该字符串，则将返回它，因此我们可以通过使用!with 获得一个布尔值.nil?。

任务9，R，16个字节

function(x,n)n*x

这将创建一个未命名的函数对象，该对象可以接受任何类型的数组或矩阵x以及一个整数，n并将xby的每个元素相乘n。如果您愿意，可以在线尝试。

任务10，Python 3，92字节

n=int(input())
l="\n"
w=" ()--() "
print(" ______  "*n+l+"|      | "*n+l+(w+"~")*(n-1)+w)

非常简单。您可以在线尝试。

任务1，> <>，​​10 + 3 = 13字节

::*-:*4,n;

使用运行此正式Python解释器使用-v标志（在3个字节的成本）。这个平方量(n - n*n)和除以4，这当然相当于平方(n*n - n)和除以4。

任务2，GAP，63 62字节

b:=function(m)return[2]=AsSet(Factors(m+1))and IsPrime(m);end;

（通过反写等号节省了空间。）

任务3，R，43 39字节

f=function(v)sort(v,d=T)[length(v)%/%2]

感谢Plannapus的出色改进！

任务4，皮特，155 135 115 5 * 19 = 95个codels

使用Codel大小为13的在线解释器进行测试。或者使用您喜欢的解释器-如果您喜欢的话，请告诉我！

使它输出0而不是输入空字符串0很不方便。我在开始时就使用了if-then来处理这种情况；然后是while循环以计算非零情况下的数字，最后是另一个while循环，最后从堆栈中输出数字。

非常感谢Sp3000提供的一些非常有用的注释，这些注释帮助我节省了一些代码！

任务5，Lua，52个字节

print"pneumonoultramicroscopicsilicovolcanoconiosis"

您可以在这里尝试。

任务6，乳胶，157个 139 136 127 128字节

\documentclass{book}\begin{document}\count1=\day\multiply\count1 by\month
\ifcase\count1\or Happy New Year!\else~\fi\end{document}

如果日期和月份的乘积是1，则打印消息；否则，什么都没有。（元旦对于这种设计特别方便：由于我们要查找的输出是1，所以我们只需要一个or语句n。th or语句指定值的行为n。）

注意：我的先前版本缺少行返回，这是一个错误。（我确实尝试测试此功能，但要正确测试它可能需要一段时间...）

我的原始版本使用了该calc软件包，该软件包比我当前的版本要方便得多。为“现实生活”牢记的东西！

任务7，Ruby，62个字节

for r in Array(13312..19893).sample(64)
puts [r].pack('U*')end

任务8，JavaScript，78个字节

h=function(l,m){u=1+m.indexOf(l[0]);return(!l||u&&h(l.substr(1),m.substr(u)))}

递归解决方案，测试是否l为的子字符串m。如果l为空，则!l结果为true并且函数终止。（在这种情况下，l[0]是undefined，但是JavaScript可以做到这一点。）否则，它将查找l[0]in 的第一个实例m。如果找不到一个，则m.indexOf(l[0])结果为-1，u结果为0，函数终止。

否则，它将剥离的第一个条目l和第一个u条目，m然后继续检查。

任务9，Python，72个 60字节

def i(a,n):
 try:return[i(c,n)for c in a]
 except:return n*a

向下钻取到“最低级别”，这里a不再是列表，而只是一个整数，然后执行乘法。

非常感谢Dennis为我节省了12个字节！

任务10，Groovy，81字节

def j(n){(' ------  '*n+'\n'+'|      | '*n+'\n'+' ()--() ~'*n).substring(0,27*n)}

在这里尝试。我最初尝试实现类似于Python的.join()字符串方法，该方法将字符串与特定的“链接字符串”（例如火车之间的链接）放在一起。但这比节省的成本要多得多。

我希望我不会违反使用这些各种语言的可接受答案的任何约定，但是请告知我是否有。

感谢Dennis的艰巨挑战！

任务1，Pyth，5个字节

s^R3Q

从标准输入取数字。感谢@Jakube指出了无用的U。

任务6，javascript，56个字节

if(Date().slice(4,10)=="Jan 01")alert("Happy New Year!")

任务7，CJam，16个字节

6581,mr64<'㐀f+

生成范围，随机播放，选择前64个，映射起始值的加法并转换为字符。14个字符，16个字节。

任务8，八度，23字节

@(x,y)intersect(x,y)==x

定义匿名函数。

任务5，PHP，45字节

pneumonoultramicroscopicsilicovolcanoconiosis

不压缩，仅打印。

任务9，APL 1个字节

 ×

与K答案相同。

任务1，R，21 19字节

sum((1:scan()-1)^3)

非常坦率的。来自STDIN的输入。

任务2，Perl，40 66字节

$a=log(<>+1)/log(2)+1;print$a==int($a)&&(1x$a)!~/^1?$|^(11+?)\1+$/

添加了素数检查器（Abigails素数检查器正则表达式）

任务3，PARI / GP，24 22字节

m(v)=vecsort(v)[#v\2];

我第一次碰到这个。可能需要学习更多。

任务4，T-SQL，235字节

CREATE FUNCTION D(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT @/-2+(IIF(@%-2<0,1,0))D,CAST(ABS(@%-2) AS VARCHAR(MAX))M UNION ALL SELECT D/-2+(IIF(D%-2<0,1,0)),CAST(ABS(D%-2)AS VARCHAR(MAX))+M FROM R WHERE D<>0)SELECT M FROM R WHERE D=0

使用递归CTE的内联表功能。很大，但是很有趣。

使用

SELECT * FROM D(18)
M
------
10110

任务5，GAP，48个字节

"pneumonoultramicroscopicsilicovolcanoconiosis";

任务6，Excel，51个48字节

=IF(TEXT(NOW(),"md")="11","Happy New Year!","")

感谢@Bond提供了3个字节。

任务7，Python 2.6中，98 93 85个字节

from random import*
l=range(13312,19893)
shuffle(l)
print ''.join(map(unichr,l[:64]))

这是我第一次尝试在Python中执行任何操作，因此可能会更好。感谢@Dennis和@Jacob的出色提示

任务8，TCL，57字节

proc m {a b} {string match [regsub -all (.) $a *\\1]* $b}

删除空白杀死这个的耻辱

任务9，派克，53个字节

mixed m(array(array(int))a,int n){return(a[*])[*]*n;}

返回相乘数组的函数

任务10，Powershell，88字节

Function t($n){Foreach($s in "  ______ "," |      |","~ ()--() "){($s*$n).Substring(1)}}

Powershell功能。我想可以将其缩短一点，但是现在就在这里。

最后完成:)

任务2，J，10个字节

1&p:*/@,#:

如果输入为其二进制表示形式的质数，则在布尔值0或1之前加一个布尔值，然后取乘积。适用于当前版本的J。

任务5，HTML，45字节

pneumonoultramicroscopicsilicovolcanoconiosis

任务6，鱼，53个字节

test 0101 = (date '+%d%m');and echo 'Happy New Year!'

基于bash的答案。

任务8，APL，12个字节

{(⍳⍴⍺)≡⍋⍵⍳⍺}

这是一个函数表达式。它将比较在较大字符串中找到的字符的顺序与将其排序后的预期顺序。

任务9，K，1个字节

*

应该适用于任何版本。算术运算分布在数组上。

任务1，Ruby，40个字节

def f n;(0..n-1).inject{|a,b|a+b**3};end

第一次用Ruby编写任何东西。用红宝石1.8.7进行测试。

任务2，R，50个字节

n=scan();p=log(n+1,2);!p%%1&sum(!n%%2:n,!p%%2:p)<3

计算p，检查它是否为整数，以及n和p是否为质数。

任务5，PostgreSQL，54个字节

SELECT'pneumonoultramicroscopicsilicovolcanoconiosis';

任务6，Lua，55个字节

print(os.date("%j")=="001" and "Happy New Year!" or "")

任务8，Python，65个字节

import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))

用法：

>>> import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))
>>> f('abc','axbxcx')
True
>>> f('bac','axbxcx')
False
>>> f('abc','axdxcx')
False
>>> f('abc','abc')
True

任务10，朱莉娅，73个字节

f(n)=print(" ______  "^n*"\n"*"|      | "^n*"\n"*(" ()--() ~"^n)[1:9n-1])

感谢@AlexA。帮助缩短此代码！输出示例：

julia> f(0)




julia> f(1)
 ______  
|      | 
 ()--() 

julia> f(2)
 ______   ______  
|      | |      | 
 ()--() ~ ()--() 

julia> f(3)
 ______   ______   ______  
|      | |      | |      | 
 ()--() ~ ()--() ~ ()--() 

任务1，Haskell，17个字节

f x=(x*(x-1)/2)^2

任务2，Mathematica，30个字节

PrimeQ@#&&Mod[Log2[#+1],1]==0&

任务3，JavaScript，46字节

function(x){return x.sort()[0|(x.length-1)/2]}

任务5，MATLAB，47个字节

'pneumonoultramicroscopicsilicovolcanoconiosis'

任务6，Ruby，56个字节

print Time.now.to_s[5,5]=="01-01"?"Happy New Year!":""

任务7，Python，106个字节（以缩进\t）

from random import*
s=''
while len(s)<64:
    c=unichr(randint(0x3400,0x4DB5))
    if c not in s:
        s+=c
print s

需要注意的是简单的使用list(set(s))也不会在这里工作，因为这将导致空间非均匀概率分布的所有可能的字符串，由于重新排序列表中的成员。

任务1，Haskell，15个字节

f n=(n*n-n)^2/4

任务2，Julia，28个字节

n->(isprime(n)&&ispow2(n+1))

任务3，八度，30字节

@(x)sort(x)(ceil(length(x)/2))

任务5，Yacas，45字节

pneumonoultramicroscopicsilicovolcanoconiosis

任务6，Mathematica，46个字节

If[DateList[][[{2,3}]]=={1,1},Happy New Year!]

任务9，PARI / GP，10个字节

(n,a)->n*a

任务3，剪辑，13个字节

gHk[tivt}l`sk

另一个版本：

gHkci`v``l`sk

的 `似乎花费太多。

任务4，KSFTgolf，16个字节

g:]2%:)-2/:;xgpc

口译员在这里。我不确定自己在做什么...它将打印负号，然后崩溃。

解释器中有一个错误。或者，我将能够使用内置的基数转换将其压缩到12个字节（但仅适用于正整数）：

2*02-ba'Z=;x

原始CJam版本：

qi{_1&_@^-2/}h;]W%

我尝试了Pip，Ostrich，Clip和Burlesque来确定是否存在带有内置负整数的esolang。他们都没有工作。KSFTgolf二手numpy，当基数为负数时，它似乎具有一些简便的怪异行为。但是要使其与非正数一起使用并不容易。

任务7，CJam，15个字节

'䶶,DAm<>mr64<

任务8，APL，21字节

∨/↑{⍺∧0,2∧/∨\⍵}/⌽⍞=↓⍞

在线尝试。

任务2，x86 masm，40个字节

C7 45 FC FF FF 07 00 B9 
00 00 00 00 B8 02 00 00 
00 D3 E0 3B 45 FC 7D 03 
41 EB F1 B8 02 00 00 00
D3 E0 48 3B 45 FC 75 13

（不包括标题，MessageBox等-仅相关字节）

include     \masm32\include\user32.inc  
includelib  \masm32\lib\user32.lib

.data
    ClassName   db "Mersenne Prime Found",0
.data?

.code
start proc
    LOCAL IsMersenne: DWORD
    mov IsMersenne, 524287 ; put number to test in this input
    mov ecx, 0
l00p:
    mov eax, 2
    shl eax, cl
    cmp eax, IsMersenne
    jge br3ak
    inc ecx
    jmp l00p
br3ak:
    mov eax,2                                                                                     
    shl eax, cl 
    dec eax
    cmp eax, IsMersenne                                                           
    jnz n0pr1me                                                              
    invoke MessageBox, 0, addr ClassName, addr ClassName, 40h
n0pr1me:
    ret
start endp
end start

任务3，C，136个字节

#include<stdio.h> 
int C(void*A,void*B){return(*(int*)A-*(int*)B);} 
main(){int S=4;int A[]={3,1,2,4};qsort(A,S,4,C);printf("%i",A[((S&1)?S:S-1)/2]);}

编译使用 gcc -o Prime main.c

任务10，C ++，478字节

#include<stdio.h>
#include<string.h> 
#include<stdlib.h>
void D(int Z){int L=9,i,X=0;const char*A=" ______  ";const char*B="|      | ";const char* C = " ()--() ~ ";char*P=(char*)malloc(27*Z+5);for(i=0;i<Z-1;i++){if(!i){memcpy(P,A,L);X+=L;}memcpy(&P[X],A,L);X+=L;if(i==Z-2){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],B,L);X+=L;if(i==Z-1){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],C,L);X+=L;if(i==Z-1)P[X-1]='\0';}printf("%s\n",P);free(P);}
main(){D(15);}

编译使用 g++ -o Trucks main.cpp

C＆C ++可以缩短，但会增加编译器错误。不知道确切的规则，所以我试图留下没有编译器错误的代码。

任务1，Python，35字节

lambda x:sum(_**3for _ in range(x))

任务3，CJam，9个字节

q~$_,(2/=

任务4，JavaScript，55 53字节

function(n){s=0xAAAAAAAA;return((n+s)^s).toString(2)}

任务5，Pyth，46字节

"pneumonoultramicroscopicsilicovolcanoconiosis

任务6，C＃，65个字节

string c(){return DateTime.Now.DayOfYear<2?"Happy New Year!":"";}

任务1，jq，24个字节

[range(1;.)|.*.*.]|add+0

任务6，PostgreSQL，54个字节

select'Happy New Year!'where'001'=to_char(now(),'DDD')

任务1，Cjam，7个字节

q~,:+_*

编辑：刚注意到马丁张贴在我面前。我会尝试其他的...

任务3，Python，30个字节

lambda l:sorted(l)[~-len(l)/2]

Python 2。

任务5，///，45个字节

pneumonoultramicroscopicsilicovolcanoconiosis

///只会回显没有任何/字符的东西。

任务7，Pyth，19个字节

s>64.SmC+13312d6582

程序。请告诉我我算不算数学。在这里尝试

任务9，八度，9字节

@(a,n)a*n

匿名函数句柄。八度自动使用矩阵*标量执行此操作。

我还没有时间尝试所有这些方法，但这是一个开始

任务1，直流电，8字节

d1+*d*4/

按照dc约定，输入和输出到堆栈的顶部。

任务5，Emacs Lisp，46字节

'pneumonoultramicroscopicsilicovolcanoconiosis

滥用规则：

grep 'pn.*v' /usr/*/*/brit*-large

在Perl中，我可以通过压缩格式解包的最佳方式是55：

unpack("H45",'uïFVóÙ¤¼g°0Æö<¥le°°')=~y/0-9bdf/i-v/r

（以上无法打印的字符被SE弄乱了，但由于这实际上不是我的答案，因此我没有解决问题）

任务6，SQL，54个字节

SELECT IF(now()LIKE'%-01-0_%','Happy New Year!','Hi');

我认为一月的前十天是此问候的“适当”日子，但您可以根据自己的喜好进行调整。该now() LIKE构造比用提取一年中的日期要短DATE_FORMAT(now(),'%j')。

任务10，sed，58个字节

s/./ ()--() ~/g;s/.$//;h;y/()-~/___ /;p;g;y/ ()-~/|    /;G

一元输入。

任务5，MarioGolf，50个字节

这是我已经开发了一段时间的语言。

当前版本具有足够的功能来运行此挑战。

Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

您可以在http://htmlpreview.github.io/?https://raw.githubusercontent.com/ismael-miguel/mariogolf/master/js/testpage.html#c:Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O上在线尝试

当前，开发已停止并且实现尚不完整。

最近一次提交是在2015年3月13日。

任务6，PHP，37个字节

这真的很容易，也很有趣！

<?=date(jn)==11?'Happy New Year!':'';

任务10，JavaScript，121个byes

是的，不是那么打高尔夫球...

但这确实可以做到！

console.log((' ______  '.repeat(i=prompt()))+'\n'+('|      | '.repeat(i))+'\n'+(' ()--() ~'.repeat(i).replace(/~$/,'')));

试试吧：

//Required to show the console messages on the document
console._RELAY_TO_DOC = true;

console.log((' ______  '.repeat(i=prompt()))+'\n '+('|      | '.repeat(i))+'\n '+(' ()--() ~'.repeat(i).replace(/~$/,'')));

<script src="http://ismael-miguel.github.io/console-log-to-document/files/console.log.min.js"></script>

由于代码从"输出开始，因此无法在堆栈代码段中很好地显示。增加了专用空间以补偿它。

原始代码可以在Chrome的控制台上执行，没有任何问题，并且输出将是预期的。

任务1，CJam，10个字节

li,{3#}%:+

在这里尝试

任务5，视网膜，46个字节

<empty>
pneumonoultramicroscopicsilicovolcanoconiosis

任务1，八度，15字节

@(n)(n^2-n)^2/4

编辑：我以为我添加了此，但似乎我忘了保存：这使用了以下事实： sum(1^3+2^3+3^3+...+n^3) = sum(1+2+3+...+n)^2 = [n*(n+1)/2]^2

任务3，JavaScript，24字节

x=>x.sort()[x.length>>1]

好吧，让我们先完成简单的工作：

任务5，ASP，45字节

pneumonoultramicroscopicsilicovolcanoconiosis

任务6，JavaScript，46字节

/an 01/.test(Date())&&alert("Happy New Year!")

任务1，VBA，126个字节

Function f(n As Integer)
    Dim i As Integer
    For i = 0 To n - 1
        f = f + i ^ 3
        Next i
End Function

我不知道如何在VBA中打高尔夫球。我没有键入单个空格，VBA会自动插入空格。=f(5)在Excel的单元格中将显示100。

任务2，八度，32字节

@(n)isprime(n)&~mod(log2(n+1),1)

任务5，Golfscript，47个字节

"pneumonoultramicroscopicsilicovolcanoconiosis"

任务9，MATLAB，9个字节

@(A,n)A*n

好吧，这是一个开始...