编写尽可能短的程序，这样，当您将第一个字符和其后的每个第N个字符组合到一个新程序中时，输出为N。这必须适用于N = 1、2，...，16。

换句话说，如果从程序中删除除第一个字符外的所有字符，然后再去除第N个字符，则其余代码的输出应为N。

例

如果您的代码是

ABCDEFGHIJKLMNOP

N = 1导致ABCDEFGHIJKLMNOP。运行该命令应输出
1。N = 2导致ACEGIKMO。运行此命令将输出
2。N = 3得出结果ADGJMP。运行此命令应输出
3。N = 4将得出AEIM。运行此命令将输出4。N
= 5导致AFKP。运行此命令应输出5。N
= 6得出结果AGM。运行此命令应输出6。N
= 7得出结果AHO。运行该命令应输出7。N
= 8导致AI。运行此命令应输出8。N
= 9得出AJ。运行此命令应输出9。N
= 10的结果为AK。运行此命令应输出10。N
= 11得出结果AL。运行它应该输出11。N
= 12结果AM。运行此命令应输出12。N
= 13得出结果AN。运行此命令应输出13。N
= 14得出结果AO。运行此命令应输出14。N
= 15得出结果AP。运行此命令应输出15。N
= 16的结果为A。运行它应该输出16。

细节

• 允许所有字符，包括ASCII和非ASCII。（还允许使用换行符和不可打印的ASCII。请注意，回车和换行符应作为不同的字符计数。）
• 分数是未更改程序的长度（以字符为单位）（例如15）。最低分获胜。
• 分数低于16显然是不可能的，因为那时至少有两个更改过的程序是相同的。
• 输出可能是文件或stdout或其他任何合理的结果。但是，这16个不同程序的输出必须全部转到相同的位置（例如，如果AO转到stdout而不是A转到文件，则不可以）。没有输入。
• 输出必须为十进制，而不是十六进制。实际输出应仅包含1或2个字符，这些字符构成从1到16的数字。（像Matlab这样的东西ans =都可以。）
• 您的程序不必在N = 17或更高的条件下运行。

APL，49

⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2

变更程序

1  ⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2
2  ⌊⍟7⍟|21189×1×345× 1  ⍝⍝_2
3  ⌊○⍟/119-××5 1 ⍝ 2
4  ⌊7|18××4×1 ⍝2
5  ⌊⍟21×○5   
6  ⌊⍟19×51⍝2
7  ⌊11-4 ⍝
8  ⌊|8×× 2
9  ⌊/9×1 
10 ⌊2×5 
11 ⌊11 ⍝
12 ⌊1×12
13 ⌊13 
14 ⌊14⍝
15 ⌊15 
16 ⌊8×2

讲解

我将从最下面开始，因为这将使解释更容易

请记住APL的两种语言功能。第一，APL没有运算符优先级，语句始终从右到左求值。有两个，许多APL函数的行为完全不同，这取决于是在其右侧给出一个自变量（单声道）还是在其左侧和右侧给出两个自变量（二进角）。

Monadic ⌊是向下舍入的（底函数），Dyadic ×显然是乘法的，⍝注释掉其余部分
这应该使这些变得显而易见：

16 ⌊8×2
15 ⌊15 
14 ⌊14⍝
13 ⌊13 
12 ⌊1×12
11 ⌊11 ⍝
10 ⌊2×5 

9：⌊/9×1
/是减少 基本上，它采用左边的函数和右边的数组，在数组的每对元素之间插入函数并求值。（在某些语言中
，这称为“折叠”）。这里，正确的参数是标量，因此/什么也不做。

8：⌊|8×× 2
一元×是符号函数和一元|绝对超值功能，因此，× 2计算结果为1和|8×1当然是8

7：⌊11-4 ⍝应该很明显

6：⌊⍟19×51⍝2
一元⍟是自然对数
因此，⍟19×51计算结果为ln(19×51) = 6.87626...，和⌊回合下来到6

5：⌊⍟21×○5
单子○乘以π
⍟21×○5为ln(21×5π) = 5.79869...

4：⌊7|18××4×1 ⍝2
二元|是MOD函数
×4×1的计算结果为1，和7|18×1是18 mod 7 = 4

3：以⌊○⍟/119-××5 1 ⍝ 2
空格分隔的值是一个数组。请注意，在APL中，当大多数标量函数被赋予数组参数时，它是一个隐式映射。
Dyadic ⍟是log
So ××5 1，是5和1上的正负号的符号，给出1 1，119-1 1是¯118 ¯118（¯只是负号。APL必须区分负数和减法），并且⍟/¯118 ¯118是log _-118（-118）= 1

2：⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
您可以自己解决

1：⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
这是对的更复杂使用/。如果n是一个数字，F是一个函数，并且A是一个数组，则nF/A采用和apply的每组n连续条目。例如，取每对连续的条目（和和）并应用于每个组以得出 So，就返回（因为它适用于标量）。然后，应用ln，然后将₇记录到这些数字，然后将它们分别乘以π和ln。另一边出现的数字在 这里，仅用于选择数组的第一个元素。AF/2×/1 2 31 22 3×/2 6
1|/2111118 92111118 9|/⍟○7⍟⍟1.46424... 0.23972...
⊃

Python- 1201 1137（生成器：241 218）-哈希万岁！

战略：

我试图从每一行开始以与所需输出一样多的哈希值开始n。然后所有其他版本将完全跳过此行。

但是，主要困难是要添加正确数量的哈希，以便下一次运行将准确地到达下一行的开头。此外，可能会干扰其他版本，例如版本16跳到print第5行的命令中，依此类推。因此，这是很多试验和错误，再加上用于快速测试的帮助脚本。

统计：

• 字元：1201 1137
• 哈希值：1066 1002（88.1％）
• 非哈希：135（11.9％）

码：

#
print 1#####
#p#r#i#n#t# #2######################
##p##r##i##n##t## ##3###
###p###r###i###n###t### ###4
####p####r####i####n####t#### ####5#########
#####p#####r#####i#####n#####t##### #####6##########
######p######r######i######n######t###### ######7###########
#######p#######r#######i#######n#######t####### #######8###
########p########r########i########n########t######## ########9##
#########p#########r#########i#########n#########t######### #########1#########0##
##########p##########r##########i##########n##########t########## ##########1##########1##
###########p###########r###########i###########n###########t########### ###########1###########2##
############p############r############i############n############t############ ############1############3##
#############p#############r#############i#############n#############t############# #############1#############4##
##############p##############r##############i##############n##############t############## ##############1##############5##
###############p###############r###############i###############n###############t############### ###############1###############6

测试脚本：

with open('printn.py', 'r') as f:
    c = f.read()

for n in range(1, 17):
    print "n =", n, "yields",
    exec c[::n]

输出：

n = 1 yields 1
n = 2 yields 2
n = 3 yields 3
n = 4 yields 4
n = 5 yields 5
n = 6 yields 6
n = 7 yields 7
n = 8 yields 8
n = 9 yields 9
n = 10 yields 10
n = 11 yields 11
n = 12 yields 12
n = 13 yields 13
n = 14 yields 14
n = 15 yields 15
n = 16 yields 16

更新：生成脚本！

我考虑过我的解决方案，必须要有一种算法来生成它的模式。所以我们开始：

lines = ['#']
for i in range(1, 17):
    lines.append(('#' * (i - 1)).join('\nprint ' + `i`))
    fail = True
    while fail:
        while ''.join(lines)[::i].find('print ' + `i`) < 0:
            lines[i] = '#' + lines[i]
        fail = False
        for n in range(1, 17):
            try:
                exec ''.join(lines)[::n]
            except:
                lines[i] = '#' + lines[i]
                fail = True
                break
print ''.join(lines)

它逐行构建程序：

1. 从哈希开始。
2. i用print i命令添加新行，并i - 1在每两个相邻字符之间添加哈希。
3. 当前程序的“ i版本”（每个i字符）不包含命令print i（由于未对齐）或任何n带有n in range(1, 17)异常的-version，请在上一行添加另一个哈希。

实际上，它返回的程序比今天早上手动找到的程序要短。（因此，我在上面更新了我的解决方案。）此外，我很确定在这种模式下不会有更短的实现。但是你永远不知道！

Golfed版本- 241 218：

h='#';L=[h];I=range(1,17);J=''.join
for i in I:
 p='print '+`i`;L+=[(h*(i-1)).join('\n'+p)]
 while 1:
  while J(L)[::i].find(p)<0:L[i]=h+L[i]
  try:
   for n in I:exec J(L)[::n]
   break
  except:L[i]=h+L[i]
print J(L)

请注意，可能会有一个较短的生成器，例如，通过对每个行的所需连续哈希数进行硬编码来实现。但这是由他们自己计算的，可以用于任何N> 16的情况。

Befunge 93-五百万七百六十五万七千七百七十六个字符

我要求认真对待...

v                                                                               &(720 720 - 80) X SPACE
""""""""""""""""                                                                &(720 720 - 80) X SPACE
1234567890123456                                                                &(720 720 - 80) X SPACE
"""""""""1111111                                                                &(720 720 - 80) X SPACE
,,,,,,,,,"""""""                                                                &(720 720 - 80) X SPACE
@@@@@@@@@,,,,,,,                                                                &(720 720 - 80) X SPACE
         ,,,,,,,                                                                &(720 720 - 80) X SPACE
         @@@@@@@                                                                &(720 720 - 80) X SPACE

3个原因。第一个原因：Bungege脚本始终为80x25，因此无论如何，必须在代码行中减少一些内容。第二个原因：为什么大约有550万个空格是因为720 720是1到16的最小公倍数。这意味着当我们跳过字符时不会出现混乱。第三个原因：哇，这很荒谬。

209个字符（多种语言）

我只是试图使事情简单，并避免将很多重要因素放在任何位置。优点是能够以多种脚本语言运行。它应该以任何非故意变态的语言工作，并具有以下功能：

• 整数文字
• 基本算术运算符+，-（减和取反），*，/
• 打印裸表达式的求值
• 有一个字符，开始一行注释

例如，

Python 2命令行解释器（尽管不是来自文件）：

+                1 #            4 /   23      #    #   5            #            9   #            7   6 *         #    # -        5     2   *  -        ##  2        6   #2                     *   2       6   4

MATLAB（只需将'＃'替换为'％'）：

                 1 %            4 /   23      %    %   5            %            9   %            7   6 *         %    % -        5     2   *  -        %%  2        6   %2                     *   2       6   4

注意：第一个“ 1”之前应该有17个空格。你们知道很多语言，因此请帮助我列出更多可以在（：：

编辑：为Python添加0位置的一元+，以避免缩进该行。

CJam，89个字节

GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-

这种方法不使用任何形式的注释。

i强制转换为整数，因此这里是noop。可以用空格代替，但是字母对我来说似乎更易读...

通过执行以下代码在线尝试：

G,{)
"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"
%_~}%N*

运行示例

$ cat nth-char.cjam 
G,{)"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"%_~}%N*N
$ cjam nth-char.cjam 
GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-
1
GiH(A(i)i((i((iii)(i(((
i(i(ii(ii(-(iii(ii(i-
2
GA(5ii(-(-ii(((iii(i(i(iii(((i
3
GHAii((ii(((iii(i-iii(-
4
GH(i(iii(i(i(i(ii-
5
G(i((i((i(((i((
6
G5)-ii(iii(i(
7
GAi(i(iiiii-
8
G5(-(i(ii(
9
G((i((((i
10
G7ii(i(i-
11
Gi((i(i(
12
Gi((ii(
13
G)i(i((
14
Giii(i
15
Giiiii
16

GolfScript，61个字节

1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6

这利用了注释（#）和未记录的“超级注释”的优势（不匹配项之后的所有内容都}将被忽略）。

_没事。可以用空格代替，但下划线对我来说似乎更易读...

在线尝试。

运行示例

$ cat nth-char.gs
16,{)"1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6"\%.~}%n*
$ golfscript nth-char.gs
1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6
1
1)##;0238(}}}} }(_
}4)+_(__;}_6
2
1_#025(;}}}_
)))(};_6
3
1#;28}} (
4+(_}6
4
1;05}_}64)__6
5
1#2(}}
)(;6
6
1;3; 6)_}
7
1;8}(4(}
8
10(}
);
9
10}}4_6
10
11}_+_
11
12}
(6
12
13})_
13
13 )}
14
15})6
15
18((
16