您的老板刚刚通过电子邮件给您列出了他需要尽快完成的12个编程任务的列表。任务很简单，但是作为社交网络支持的年轻软件大亨，您的老板坚持认为，您的解决方案必须能够在单个Twitter微博中使用。

这意味着您只有140字节的代码可解决所有任务，平均每个任务11.67字节。（是的，Twitter 计算字符，但您的老板专门说了字节。）

您意识到无法解决140字节中的所有12个任务，但是您怀疑老板不会实际测试所有解决方案。因此，您可以继续解决尽可能多的任务，而完全跳过其中的一些任务。您的心态是，完成任务的哪个子集无关紧要，只重要的是子集尽可能大。

您可以完成多少个任务？

挑战

编写多达12个不同的程序，每个程序都能准确解决以下12个任务之一。这些程序的长度的累积总和不能超过140个字节

或者，您可以编写一个长度不超过140个字节的程序，该程序取1到12之间的整数，并且（理想情况下）继续解决相应的任务，并根据需要输入更多的信息。并非所有任务都需要工作，只有那些确实可以计入您的分数的任务才能工作。无效的任务将允许错误或执行其他任何操作。

在任何一种情况下，“程序”实际上都是将输入作为参数或对其进行提示并打印或返回输出的函数。因此，例如，您可以编写一个看起来像的140字节的函数f(taskNumber, taskInput)，或者您可以为每个任务编写单独的代码段，其中一些作为函数，而某些则作为成熟的程序。

其他详情：

• 所有代码必须使用相同的语言编写。

• 像往常一样，输入应该来自stdin，命令行，函数参数或您的语言常用的东西。输出将输出到标准输出或您的语言最接近的替代版本，或以适当的类型返回。

• 合理数量的输入格式是可以的；例如，用引号引起来的字符串或\n代替实际的换行符。

• 输出应该完全是所要求的，没有多余的格式或空格。唯一的例外是尾随换行符。

• 仅在REPL环境中运行的代码不构成程序或功能。

• 您可能不会编写解决多个任务的多个程序。是一个程序（理想地）解决所有任务，或者是（理想地）12个程序分别解决一个任务。

• 未经原作者的署名，并且最好也获得许可，不允许发布您未编写或仅稍作修改的任务解决方案。如果您的答案主要是所有其他答案中最短的解决方案，则它应该是社区Wiki。

计分

完成最多任务的提交是获胜者。如果两个提交并列，则字节数最少的一个获胜。如果字节计数并列，则较早的提交将获胜。社区维基答案不允许获奖。

确保告诉我们您解决了哪些任务，而不仅仅是告诉我们！

非高尔夫球员的障碍：

这项挑战很可能将以高尔夫语言为主导。许多语言甚至可能无法解决140字节内的一两个任务。因此，您可以提交非竞争性答案，其限制为3条推文，即420字节。所有其他规则保持不变。

任务

任务1-三个数字可以形成三角形吗？

取三个正整数并输出一个true / falsy值，该值指示具有这些长度的三行是否可以形成三角形。您可能不认为数字按任何特定顺序排列。

真实的示例（每行一个）：

20 82 63
1 1 1
2 3 4
1 2 2

虚假的例子：

6 4 10
171 5 4
1 1 2
1 2 3

任务2-接近一百万

给定一个正好是7个十进制数字（0-9）的字符串，请重新排列它们以获得尽可能接近一百万的数字。也就是说，abs(1000000 - rearrangedNumber)应将其最小化。

将结果数字打印或返回为整数，而不是字符串（因此，除非这是您所用语言的规范，否则不应以零开头）。

例如，输入的9034318结果应为984331（而不是1033489）。

2893984应该成为2348899。

0001000应该成为1000000。

0000020应该成为200000。

任务3-简单的键盘模拟器

输入一串小写字母（az），空格和尖括号<>。从左到右读取，该字符串表示打开最初为空的文本编辑器时在标准键盘上按下的键。字母和空格对应于它们的常规键，但<对应于左箭头键和>右箭头键，当按下它们时，它们都将移动光标。

<将光标向左移动一个字符；如果光标位于字符串的开头，则不执行任何操作。
>将光标向右移动一个字符，如果光标位于字符串的末尾，则不执行任何操作。

按下输入字符串中的所有键后，输出将在文本编辑器中显示的字符串。不允许输出转义码来移动光标。

输入中将始终至少有一个非箭头键字符。

例如输入ui<<q>>ck <<<<<<the<<<<>>> >>>>>>>>brown x<o<f应该屈服the quick brown fox。

op<<l>>t<<<lam>>>>>>imi<<<><>>>zer<<<<<<<<<<<<<<<<<<>>><>m应该给llammoptimizer。

e< <c<b<a应该给abc e。

<<<>><><<><toast>><<>><><<>><应该给toast。

任务4-填写信件

在许多字体，大写英文字母的6完全由水平线和垂直线：E，F，H，I，L，和T。我们称这些为FILTHE字母。

输入一串大写字母（AZ）并计算FILTHE字母中的行数，并输出结果整数。

E，F，H，I，L，和T分别具有4，3,3，3，2和2行。

例如GEOBITS，FILTHE字母（用于.E..IT.）有4 + 3 + 2 = 9行，因此输出应为9。

ABCDEFGHIJKLMNOPQRSTUVWXYZ应该输出17。

ABCDGJKMNOPQRSUVWXYZ应该输出0。

FILTHYLINESINLETTERS应该输出39。

任务5-亚历克斯递归 A.

我们的主持人Alex A.的名字缩写为“ A”。

现在我不确定，但我认为A.代表.A xelA。而且我也很确定.A那儿偷偷摸摸地代表Alex A.。

因此，要获得Alex的全名，我们必须扩展A.的和.A：

Alex A. -> Alex [A.] -> Alex [.A xelA] -> Alex .A xelA -> Alex [.A] xelA -> Alex [Alex A.] xelA -> Alex Alex A. xelA -> etc.

让您的程序接受一个非负整数并将其扩展Alex A.多次，输出结果字符串。

所以
0变得Alex A.，
1变得Alex .A xelA，
2变成Alex Alex A. xelA，
3成为Alex Alex .A xelA xelA，
4变得Alex Alex Alex A. xelA xelA，
5变成Alex Alex Alex .A xelA xelA xelA，
等等。

^{（我之所以这么做，是因为我为无意中将Alex丢进我的Mod贡品挑战而感到难过。}

任务6-数字键旋转

输入1到9之间的一个整数（包括1和9）（您可以将其作为字符串）。输出3×3位数的正方形

789
456
123

以90°的增量旋转，使输入数字出现在第一行的任何位置。当5被输入的任何旋转是因为有效的输出5斜面被旋转到顶部。

例如，当3输入时，两者

963
852
741

和

321
654
987

是有效的输出。

4仅用于输入

147
258
369

是有效的输出。

任务7-将数字拆分为十位数

接受一个非空的十进制数字字符串（0-9），并输出一个真实值（如果可以将其拆分为多个连续部分，其中每个部分中的所有数字精确地相加为10）。如果不可能，则输出一个伪造的值。

例如，19306128可以像一样拆分19|3061|28，所有部分的总和为10（1 + 9，3 + 0 + 6 + 1，2 + 8），因此应输出真实值。

真实的示例（每行一个）：

19306128
073
730
0028115111043021333109010
2222255

虚假的例子：

6810410
9218
12341
5222225
000

任务8-方钟

输入大小一致的多行字符串。

输出12如果输入是

 _ _
| | |
|_ _|

输出3如果输入是

 _ _
| |_|
|_ _|

输出6如果输入是

 _ _
| | |
|_|_|

输出9如果输入是

 _ _
|_| |
|_ _|

没有其他输入情况。

任务9-托架艺术

采取在含有每种左括号中的一个4字节串(，[，{，和<以任何顺序。

添加相应的右括号，使字符串长8个字节，并具有垂直对称线。例如[<({成为[<({})>]。

然后反转该字符串中的每个括号。例如[<({})>]成为]>)}{(<[。

在单独的行上分别输出原始的8字节括号字符串和上下颠倒的版本。

所以输入的最终输出[<({是

]>)}{(<[
[<({})>]
]>)}{(<[

同样，的输出<({[应为

>)}][{(<
<({[]})>
>)}][{(<

输入(<<[无效，因为{缺少，并且有一个额外的<。

任务10-个性化

取一个矩形的文本网格（最小1×1），由.代表空白空间的和X代表实心砖的组成。超出网格边界的单元格被视为空单元。您可以假设4个网格边缘行和列中的每一个都至少包含一个X。

例如，有效的输入可能是：

XXX.....X.....
X..X...X.X....
XXX.....X....X

输出另一个矩形的文本网格，每个与X正交或对角线相邻的空单元格（包括输入网格外部的每个空单元格）变为o。因此，基本上是在实心砖的o所有部分周围绘制的的permiter 。新的网格不应大于必须的大小。

因此，上面示例的输出将是：

ooooo...ooo.....
oXXXoo.ooXoo....
oXooXo.oXoXo.ooo
oXXXoo.ooXoo.oXo
ooooo...ooo..ooo

同样，输入的输出XXX..X.X应为

oooooooooo
oXXXooXoXo
oooooooooo

并输出

oooooooooo.
oXXXooXoXo.
oooooooooo.

将是无效的，因为不需要最右边的空白列。

您可以使用任何3级不同的打印的ASCII到位的人物.，X和o。

任务11-塞特广场

输出Sator Square：

SATOR
AREPO
TENET
OPERA
ROTAS

任何字母都可以是小写或大写，因此

SatOR
aRePO
tenet
OPERa
RoTaS

也是有效的输出。

没有输入。

任务12-主推文

不输入任何内容，而是输出一个140字节的可打印ASCII字符串，该字符串包含95个可打印ASCII字符中的每个字符中的至少一个。（因此45个字符将重复。）

在此字符串中的所有140个字节的字符代码的总和必须是索菲·热尔曼质数，即质数p，从而2p+1也素。空格的字符代码是32，33表示!，34表示"，依此类推，最多126表示~。该和可以在Python中计算为sum(map(ord, myString))。

示例输出为：

! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

字符代码和为素数12203，其对应的安全素数为24407。

Pyth，136个字节中的9个任务

任务1：7个字节

<-F_SQ0

示范

按降序（_SQ）排序，将减号对折（a-b-c），然后检查结果是否为负。

任务2：14个字节

sho.a-sN^T6.pz

示范

形成所有字符串排列（.pz），并o根据.a-数字（sN）和一百万（^T6）之间的差（）的绝对值对它们进行排序（）。

取第一个这样的字符串（h），并将其转换为num。（s）。

任务4：19个字节

s/L+\EPP*3"EFHILT"z

示范

复制"EFHILT"三遍（*3），删除结尾的LT（PP），然后添加E（+\E）。将输入中的每个字母映射到该字符串中的外观计数。（/L ... z）。和。（s）。

任务5：16个字节

u+"Alex "_GhQ".A

示范

与开始"A."，反向和添加"Alex "到开始，输入+ 1次。

任务7：13个字节

}Y-RTsMM./sMz

将输入字符串转换为1位数字的列表（sMz）。形成所有分区（./）。对每个分区（sMM）的每个元素求和。从每个子列表（-RT）中删除所有10 。通过检查空白列表是否在整个列表（}Y）中，检查是否清空了所有子列表。

任务8：11个字节

*3h%%CQC\Ç4

示范

模魔术。转换为数字（CQ），将其设为199（C\Ç= 199），并将其设为4。然后加1，然后乘以3。

任务9：21个字节

J+Xz"<{[()]}>")_zJ_JJ

示范

首先，我们生成第一行，其中包括转换为镜像字符（Xz"<{[()]}>")）的输入，然后是反向输入（+ ... _z），并将其保存到J。然后打印该行，其反面并再次打印该行（J_JJ）。

任务11：22个字节

+J"SATOR
AREPO
TEN"t_J

示范

只需打印一个字符串及其反转，但不要复制中心N。

任务12：13个字节

++G*19\3srd\

示范

代码末尾有一个看不见的DEL（7F）字符。

此打印

abcdefghijklmnopqrstuvwxyz3333333333333333333 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

具有字符和11321。它由G，19个字母3和所有可打印的ASCII字符组成。

CJam，140个字节中的8个 9个任务

首先，这是一个脚本，您可以使用该脚本对解决方案进行排序，并告诉您哪些内容适合该推文：

{\s\Se[oSo}:F;
qN/ee{W=,}${)_,_T+:T140>X*_{0:X;}*'=@11+*N+*o\~)YF_,ZFTZFoNo}/

只需将12个解决方案粘贴到输入中，每行一个。在这里运行。第一列是任务号，第二列是任务的大小（以字符为单位，如果与字节数不同，则必须自己解决），第三列是累积大小。适用于该tweet的程序通过一行与其余程序分开===。

对我来说，输出看起来像这样：

 1   7   7 q~$~\->
 8  10  17 qDbJ%5/)3*
12  12  29 ',32>_51>'d
 7  13  42 Aq{~-Ace|}/N&
 2  15  57 qe!{~1e6-z}$0=~
 4  19  76 q"FIHEELT"3*H<fe=:+
 5  20  96 ".A"q~){" xelA"+W%}*
 9  22 118 q_{_')>+)}%W%+_W%N@N3$
11  22 140 "SATOR\AREPO\TEN"_W%1>
====================================
 6  25 165 9,:)s3/zq~))3mdg*{W%z}*N*
 3  43 208 LLq{_'=-z({+}{'=>_)$\[{)@+\}{\(@\+}]=&}?}/\
10  45 253 0XW]_m*qN/{'.f+W%z}4*f{\~@m>fm>N*}(\{8f^.e>}/

所以这是我目前可以在推文中完成的任务。

任务1-三个数字可以形成三角形吗？- 8个 7字节

感谢jimmy23013节省了1个字节。

q~$~\->

测试套件。

输入应为CJam样式列表。

这非常简单：检查最大边是否短于其他两个边的和。或者等效地，检查最短边是否长于其他两个边的差：

q~  e# Read and eval input.
$~  e# Sort the values and dump them on the stack.
\-  e# Subtract the middle value from largest.
>   e# Check if the smallest value is greater than that.

任务2-接近一百万-15个字节

qe!{~1e6-z}$0=~

测试套件。

简单的蛮力：

q        e# Read input.
e!       e# Get all permutations.
{        e# Sort by...
  ~      e#   Evaluate the permutation to get its numerical value X.
  1e6-z  e#   abs(X - 1,000,000)
}$
0=       e# Pick the first element (which minimises the difference)
~        e# Evaluate it to get rid of the leading zeroes.

任务4-FILTHE Letters- 21 19字节

感谢jimmy23013节省了2个字节。

q"FIHEELT"3*H<fe=:+

测试套件。

这个想法是创建一个字符串，其中包含每个FILTHE字母的每条正交线一次。这是通过一些有趣的字符串操作完成的：

q          e# Read the input.
"FIHEELT"  e# Push this string. It first contains the 3-line letters, then the 2-line 
           e# letters, where we include 'E' twice to make it count for 4.
3*         e# Repeat 3 times: "FIHEELTFIHEELTFIHEELT"
H<         e# Truncate to 17 characters: "FIHEELTFIHEELTFIH". This is chosen such that
           e# it discards the third repetition of the 2-line letters.
fe=        e# For each character in the input, count its occurrences in this new string.
:+         e# Sum them all up.

任务5-亚历克斯递归A.- 27 20字节

".A"q~){" xelA"+W%}*

测试套件。

直接取代A.和.A过于昂贵。相反，我们注意到，如果我们每次都反转字符串，则只需要处理一种情况。此外，Alex每次前置（和空格）等效于扩展首字母。我们可以通过在反转字符串之前附加反向字符来保存另一个字节：

".A"        e# Start with ".A" (the -1st iteration if you like).
q~)         e# Read input, eval, increment (so the following block is run at least once.)
{           e# Repeat this block that many times...
  " xelA"+  e#   Append " xelA".
  W%        e#   Reverse the string.
}*

任务7-将数字拆分为十进制-18 16 13字节

Aq{~-Ace|}/N&

测试套件。（每个输出均带有括号。）

并非完全用户友好：真理值是单个换行符，虚假值是空字符串。

基本思想很简单：将数字添加到运行总计中，只要精确到10，我们就会重置这些数字。输入末尾的总计必须为零。首先，结果会短于10的总数，然后减去数字，每当我们击中0时就重置总数。但是，我们需要确保当输入全为零时，我们不会返回真值。我发现这样做的最短方法是将总数重置为代码点为10 的字符（换行符），然后最后检查我们在堆栈上实际有该字符，而不是数字10。这可行，因为整数零和字符零（空字节）都是虚假的：

A     e# Push a 10, the initial running total.
q{    e# For each character in the input...
  ~-  e#   Evaluate the character to get the digit and subtract it from the total.
  Ac  e#   Push a linefeed character.
  e|  e#   Logical OR of the running total and the linefeed character (using
      e#   short-circuiting).
}/
N&    e# Take the set intersection with the string containing a linefeed character.
      e# If the total is still a number of any character other than the linefeed,
      e# this will yield an empty string. Otherwise, the string will remain unchanged
      e# and the linefeed will be printed.

任务8-方时钟-10个字节

qDbJ%5/)3*

测试套件。

这只是字符代码上的一些相当随机的模魔术，碰巧会哈希到正确的值。我完全相信可以做些更短的事情，但这是我（以编程方式）发现的最短的这种结构：

q   e# Read the input.
Db  e# Treat the character codes of the string as digits in base 13. This maps the
    e# four inputs to the values: 2023940117708546863
    e#                            2023940113755405840
    e#                            2023940781838850791
    e#                            2023940113755390292
J%  e# Take the result modulo 19. This gives [2, 5, 12, 18], respectively.
5/  e# Divide by 5 (rounding down). [0, 1, 2, 3], respectively.
)   e# Increment. [1, 2, 3, 4], respectively.
3*  e# Multiply by 3. [3, 6, 9, 12], respectively.

任务9-托架艺术-23 22字节

感谢Sp3000节省1个字节。

q_{_')>+)}%W%+_W%N@N3$

测试套件。

非常坦率的。左括号和右括号之间的映射是通过添加2（或括号为1）完成的：

q_      e# Read input and duplicate.
{       e# Map this block onto each character...
  _')>  e#   Duplicate and check if it's not a parenthesis.
  +     e#   Add the result, leaving parentheses unchanged and incrementing the
        e#   other bracket types.
  )     e#   Increment again.
}%
W%+     e# Reverse and add to the original, giving the middle line.
_W%     e# Duplicate and reverse, giving the first line.
N@      e# Push a linefeed, pull up the middle line.
N3$     e# Push another linefeed, copy the first line.

任务11-Sator Square-22字节

"SATOR
AREPO
TEN"_W%1>

在这里测试。

可能是最无聊的解决方案。它推入字符串的前半部分，然后反转它：

"SATOR
AREPO
TEN"    e# Push everything up to the centre of the square.
_W%     e# Duplicate and reverse.
1>      e# Discard the "N", because we don't want that twice.

任务12-主推文-13 12字节

',32>_51>'d

在这里测试。（带有结果的诊断输出。）

之后'是不可打印的<DEL>（0x7F），SE将其剥离。对于复制粘贴，请改用以下版本：

'~),32>_51>'d

打印的字符串是

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

也就是说，它包含所有字符的一次运行，然后是从S到的另一次运行~，然后是单个d。字符代码的总和为12203。我通过反复试验发现了这一点。

'~),32>  e# Push a string with all printable characters.
_51>     e# Duplicate this and discard the first 51 of them.
'd       e# Push a "d".

Pyth，138个字节中的9个任务

这花了很长时间。

我认为9个任务是Pyth的限制。包括下一个最短的程序（Sator Square），结果为160个字节。打高尔夫球20个字节是不太可能的。有2或3个任务有些丑陋，也许可以缩短，但总体而言，我对解决方案感到非常满意。

任务1-三个数字可以形成三角形吗？，8个字节

>FsMc2SQ

在线尝试：常规输入或测试套件

任务2-接近百万，14个字节

ho.a-^T6NsM.pz

在线尝试：常规输入或测试套件

任务4-FILTHE Letters，20个字节

s*Vtsmmdd5/Lz"TLIHFE

在线尝试：常规输入或测试套件

任务5-Alex递归A.，16字节

u+"Alex "_GhQ".A

在线尝试：常规输入或测试套件

任务6-数字键旋转，20个字节

jeo}zhN.uC_N3_c3jkS9

在线尝试：常规输入或测试套件

任务7-将数字拆分为数十个字节

qTu+WnGTvHG-zZZ

在线尝试：常规输入或测试套件

任务8-方时钟，12字节

*3%%Cz1978 5

在线尝试：常规输入或测试套件

任务9-括号艺术，20个字节

V3_WtN+z_Xz"[<({})>]

在线尝试：常规输入或测试套件

任务12-主推文，13个字节

++*d44srd\\&

在线尝试：常规输入

TI-BASIC，11 12个任务（728830字节）

任务1（7字节）

:2max(Ans)`<`sum(Ans

输入是中的列表Ans。

92 110字节中的任务2

:seq(expr(sub(Ans,I,1)),I,1,7→L₁
:SortA(L₁
:min(7,1+sum(not(L₁
:{L₁(1)+sum(seq(L₁(I))₁₀^(I-8),I,2,7)),L₁(Ans)+sum(seq((I`>`Ans)L₁(I)₁₀^(1-I),I,2,7
:ᴇ6Ans(1+(0`>`min(ΔList(abs(1-Ans

提示数字列表输入是中的字符串Ans。

119个字节中的任务3

:Input Str1
:"  →Str2
:For(I,1,length(Str1
:sub(Str1,I,1→Str3
:inString("`<>`",Ans
:If Ans:Then
:max(0,min(L,C+2Ans-3→C
:Else
:C+1→C
:L+1→L
:sub(Str2,1,C)+Str3+sub(Str2,C+1,L-C+1→Str2
:End
:End
:sub(Str2,2,L

提示输入字符串。假设C和L为未定义或为0。

任务4（35字节）

:sum(int(2seq(inString("TLIHFE",sub(Ans,I,1))^.4,I,1,length(Ans

输入是中的字符串Ans。

任务5（63字节）

:Ans/2→C
:sub("A.A",1+2fPart(C),2
:For(I,0,C
 :"Alex "+Ans
 :If I≠C
  :Ans+" xelA
:End
:Ans

输入为中的数字Ans。

任务6（66字节）

：𝑖^（（Ans <7）（Ans-3（Ans >3：For（Y，⁻1,1：Disp sum（seq（（5-real（AnsX +Ans𝑖Y）-3imag（AnsX +Ans𝑖Y））₁₀^（ X + 1），X，⁻1,1：结束

输入为中的数字Ans。

任务7（36 43字节）

:Input <strike>L₁</strike>Str1
:.5
:For(I,1,<strike>dim(L₁</strike>length(Str1
 :Ans+<strike>L₁(I</strike>expr(sub(Str1,I,1
 :If 10=int(Ans
  :0
:End
:not(Ans

提示输入数字字符串列表。

任务8（29字节）

:18fPart(sum(seq(I(sub(Ans,I,1)=" ")/6,I,1,15

输入是中的字符串Ans。

任务9（83字节）

:For(I,1,16,2
 :If I<8
  :Ans+sub("`)}]>`",inString("`({[<`",sub(Ans,4,1)),1
 :sub(Ans,I,1)+Ans
:End
:For(I,⁻1,1
 :Disp sub(Ans,9-8abs(I),8
:End

输入是中的字符串Ans。

任务10（159字节）

:1→X
:Input Str1
:2+length(Str1→L
:"X
:While 2+L`>`length(Ans
 :Ans+Ans→Str2
:End
:Ans→Str3
:While 1
 :"XX
 :Ans+Str1+Ans→Str1
 :For(I,1,L
  :Ans+sub("0X.",2expr(sub(Str2,I+1,1))+not(expr(sub(Ans,I,3)+sub(Str2,I,3)+sub(Str3,I,3))),1
 :End
 :Disp sub(Ans,L+3,L
 :Str2→Str3
 :Str1→Str2
 :Input Str1
:End

分别使用X0.而不是.Xo（对不起没有匹配项）。提示逐行输入。您必须输入Xs的两行以查看所有输出，然后单击2nd + Quit退出。

39字节的任务11

:Disp "SATOR
:Disp "AREPO
:Disp "TENET
:Disp "OPERA
:Disp "ROTAS

任务12（77个字节）

：Ans +“ tvm_I％LinReg（ax + b）DS <（getKeyconj（1-PropZTest（dayOfWk（Manual-Fit C / YANOVA（* row（HorizRegEQUnarchive [J]！＃$ &''，.234567890：; = >？@GBQX \^ _`qw {|}〜

或为十六进制：

72702ABB21FFDBADBB25BB3EEF06EF16
6331BB5917746201BB695C092DBBD2BB
D3BBD4AEAE2B3A323334353637383930
3EBBD66A6CAFBBD147425158BBD7F0BB
D9BBD5BBC1BBC708BBD809BBCF

输入是包含"in 的字符串Ans。

在TI-BASIC中，这实际上是不可能的。可以对基本程序进行十六进制编辑，并使用某些2字节的令牌将所有可打印的ascii字符获取到源代码中，但这不是问题。问题在于，没有方法，就没有办法"在没有程序输入的情况下以纯基本形式将字符存储到字符串中（这同样适用于→字符，但这不是可打印的ascii）。但是，可以将"等式放到basic之外，之后您可以使用basic将等式转换为字符串并显示该字符串。最重要的是，屏幕上每次只能显示128个字符。

Perl，117个字节中的4个任务

让我们尝试一种真实的语言;）

还没有放弃，甚至不可能在140个字节中压缩5个任务，尽管可能性不大！

*任务1：30 + 1 = 31字节

@F=sort@F;say$F[0]+$F[1]>$F[2]

用法： perl -aM5.010 entry.pl input.txt

*任务4：32 + 1 = 33字节

y/ELTFHI/4223/;s/./+$&/g;$_=eval

用法： perl -p entry.pl input.txt

任务5：54个字节

say"Alex "x($_/2+1).qw(A. .A)[$_%2]." xelA"x(--$_/2+1)

-2b感谢Dom Hastings

用法： echo 4 | perl -M5.010 entry.pl

任务7：37 + 2 = 39字节

($i+=$_)>10&&exit,$i%=10for@F;$_=!$i;

用法： perl -pF entry.pl input.txt

*任务8：21 + 2 = 23字节

$_=y/|_ 
/14/dr/64%14

这有点棘手。通过更换各开始了|与x和每个_与y然后替换空间以产生用于每个网格一个唯一的两位数字的字符串（yyxxyxxyyx，yyxxyxxyyxyyxxxxyxyx，yyxxxxyxyxyyxyxxxyyx，yyxyxxxyyxyyxxxxyyx，yyxxxxyyx）。接下来，我编写了一个程序来对x和进行暴力破解y，并用数学运算对替换后产生的数字进行运算，x并y为每个数字提供3、6、9、12的输出。最后，x=1，y=4和魔术行动是/64%14。

用法： perl -0p entry.pl input.txt

任务11：34个字节

say"SATOR
AREPO
TENET
OPERA
ROTAS"

用法： perl -M5.010 entry.pl

*任务12：30个字节

say d.pack"C*",32..126,83..126

用法： perl -M5.010 entry.pl

免责声明：-M5.010 被视为“免费”

Ruby，280个字节中的4个任务（非竞争性）

这只是一种尝试，以后我会继续做一些任务（希望打高尔夫球现有的任务）。

任务1

a=gets.split.map &:to_i;p a.all?{|e|e<a.inject(:+)-e}

任务2

p gets.chars.permutation.map{|a|a.join.to_i}.min_by{|x|(x-1e6).abs}

任务4

n,b='EFHILT',0;gets.chars.map{|c|b+=n[c]==p ? 0:[4,3,3,3,2,2][n.index c]};p b

任务5

a='Alex A.';gets.to_i.times{|i|i%2<1 ? a.sub!('A.','.A xelA'):a.sub!('.A',a)};$><<a

TI-BASIC，994个字节中的12个任务

全部下载为TI组文件（.8xg）

（按请求添加了剧透标签。）

任务1-三个数字可以形成三角形吗？-7个字节

下载为TI-83 +程序文件（.8xp）

:2max(Ans)<sum(Ans

任务2-接近百万-114字节

下载为TI-83 +程序文件（.8xp）

:int(10fPart(Ans\10^(\-cumSum(binomcdf(6,0→X
:"sum(\L\X\10^(\cumSum(not(binompdf(6,0→\Y1\
:SortD(\L\X
:\Y1\→X
:sum(not(\L\X
:If Ans
:Then
:If max(\L\X=1
:X+\E\6-\10^(\6-Ans→X
:SortA(\L\X
:augment(ΔList(cumSum(\L\X)),{0→X
:End
:{X,\Y1\
:Ans(1+(0>min(ΔList(abs(\E\6-Ans

任务3 -简单的键盘模拟器- 131个 127字节

下载为TI-83 +程序文件（.8xp）

:Input Str1
:DelVar X1→Y
:"..→Str2
:For(Z,1,length(Str1
:sub(Str1,Z,1→Str3
:(Ans=">")-(Ans="<
:If Ans
:Then
:max(1,min(Y+Ans,X+1→Y
:Else
:sub(Str2,1,Y)+Str3+sub(Str2,Y+1,X-Y+2→Str2
:X+1→X
:Y+1→Y
:End
:End
:sub(Str2,2,X

任务4-FILTHE Letters-34个字节

下载为TI-83 +程序文件（.8xp）

:sum(int(\³√(\12seq(inString("TLIHFE",sub(Ans,X,1)),X,1,length(Ans

任务5-亚历克斯递归A.-107字节

下载为TI-83 +程序文件（.8xp）

:Input X
:".A..
:For(X,0,X
:Ans→Str1
:5int(.5X+.5
:sub(Str1,1,Ans+1)+sub(".A xelAlex A.",6gcd(X,2)-5,7)+sub(Str1,Ans+4,5X-Ans+1
:End
:sub(Ans,2,5X+2

任务6-数字键旋转-86字节

下载为TI-83 +程序文件（.8xp）

:.3Ans+2(Ans=6→X
:[[9,6,3][8,5,2][7,4,1
:For(X,0,X
:rowSwap(Ans\^T\),1,3
:End
:Ans
:*row+(10,*row+(10,Ans\^T\,1,2),2,3
:For(X,1,3
:Disp Ans(3,X
:End

任务7-将数字拆分为十进制-77个字节

下载为TI-83 +程序文件（.8xp）

:Ans+"0
:seq(expr(sub(Ans,X,1)),X,1,length(Ans
:augment(Ans,{10not(not(max(Ans→X
:1→X
:Repeat Ans≥dim(\L\X
:Ans+1
:If 10=sum(\L\X,X,Ans
:Ans+1→X
:End
:X=Ans

任务8-方时钟-35字节

下载为TI-83 +程序文件（.8xp）

:12-3max(seq(X(sub(Ans,6gcd(X,2)+X,1)≠" "),X,1,3

任务9-括号艺术-86字节

下载为TI-83 +程序文件（.8xp）

:Input Str1
:For(X,1,4
:For(Y,0,1
:abs(X-9not(Y→Z
:"()[]{}<>
:sub(Ans,inString(Ans,sub(Str1,X,1))+Y,1
:Output(1,Z,Ans
:Output(2,9-Z,Ans
:Output(3,Z,Ans
:End
:End

任务10-透视-218字节

下载为TI-83 +程序文件（.8xp）

:".
:For(A,0,\E\9
:Input Str1
:Ans+Str1→Str2
:If Str1≠".
:End
:length(Ans→X
:round(A\^-1\(Ans-2→B
:seq(expr(sub(Str2,A,1)),A,2,X-1→B
:πAns→C
:"augment(Ans,augment(Ans,\L\B))+augment(Ans,augment(\L\C,Ans))+augment(\L\B,augment(Ans,Ans→X
:seq(0,A,1,B
:\L\X→A
:For(C,0,A+1
:seq(\L\A(A+BC),A,1,B→C
:int(Ans→B
:{0
:1+not(\L\X)+not(fPart(\L\X→B
:".
:For(X,1,B+2
:Ans+sub("120",\L\B(X),1
:End
:Disp sub(Ans,2,B+2
:End

进行了以下替换：0= .，1= X，2=o

对于输入（在程序开始之后），一次键入一行，在每个换行符处按Enter键，直到写出最后一行。然后按Enter键，输入一个句号，然后再次按Enter键以提交整个字符串。

任务11-Sator Square-38字节

下载为TI-83 +程序文件（.8xp）

:Disp "SATOR","AREPO","TENET","OPERA
:"ROTAS

任务12-主推文-151字节

下载为TI-83 +程序文件（.8xp）

:Ans+"!#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
:For(X,1,45
:Ans+" 
:End
:Ans

Ans应该包含双引号，方法是直接\Y1\在公式编辑器中键入一个双引号，然后Equ►String(\Y1\,Str1:Str1从主屏幕运行。

输出长度为140。8出现两次，并且有45个空格以及其他ASCII字符每个出现一次。这等于（33 + 34 + ... + 126）+ 56 + 32×45 = 8969，是索菲·杰曼的素数。

Python 3，1个任务，268个字节，非竞争性

我在Python 3.5.2中尝试了任务2，我是打高尔夫球和python的新手

import itertools
def f2(l):
    n=1000000
    l=list(itertools.permutations(l))
    j = len(l)
    m=[None]*j
    while j>0:
        j -= 1
        m[j]= int(''.join(str(i) for i in l[j]))
        l[j]=abs(n-m[j])
    l.sort()
    k=n-l[0]
    return(n+l[0],k)[k in m]