最近，有人对Python的默认行长提出了更严格的限制：

显然，出于各种原因，任何程序每行都不得使用超过80个字符。首先，对于可读性和可维护性，拥有一个坚实的标准很重要，因此我们可以适当地调整文本编辑器的宽度。作为第二个好处，代码可以轻松地转移到可能有限制的媒体上，并且添加换行符可能会分散注意力，例如打印页面供会议中查看或打孔卡。

但是80个字符太高了吗？一些建议使用79，甚至低至75，以允许80个字符宽的终端使代码适合带有几行行号的列。显然，最终，越低越好，因为较低的限制允许代码在更多情况下使用，而无需重新格式化。

介绍max6标准

您的目标是通过编写任何行中字符数最少的FizzBu​​zz变体来查找和演示“收藏夹语言”所需的最小行长。

输入项

整数n通过任何所需的方法。

输出量

从1打印编号，以Ñ，（Ñ ≥1，Ñ ∈ℤ）分离由换行，除了：

• 用于3个打印“ Apple”的倍数
• 用于5个打印“派”的倍数
• 用于3和5的倍数打印“ ApplePie”

计分

最大行长度（以字节为单位），不包括换行符（Cr，CrLf，Lf或其他系统标准中断，根据需要指定），总代码长度（以字节为单位）作为平局决胜局。

规则

所有换行符都必须有意义。可被移除和相邻的线直接连接在一起而对输出的影响换行符，必须被去除。

> <>，1个每行字节，243个 161 135字节

-26个字节，感谢Jo King！

2D语言FTW！尽管使用goto指令而不是2D结构编写循环和分支并不有趣。

v
l
:
:
3
%
:
&
0
4
7
*
&
?
.
~
~
"
e
l
p
p
A
"
o
o
o
o
o
$
5
%
:
&
0
a
5
*
&
?
.
~
~
"
e
i
P
"
o
o
o
*
0
@
?
n
?
~
l
{
:
}
=
?
;
a
o
1

在线尝试！或在鱼游乐场观看！

鱼根据代码向下游动，根据条件对累加器进行划分，使用有条件的陷阱跳过某些内容。

我认为这符合规范：无论删除换行符，鱼总是会击中开头v（出现的唯一换向指令），因此鱼总是在第一列中向下游泳。因此，删除换行符的效果只是从鱼的路径中删除下一个字符，我认为您不能在不更改输出的情况下删除任何字符。

Haskell中，3个字节/行，494个471 470 463 453 450 461字节

编辑：

• -26个字节：删除了一些多余的换行符及其相关的注释标记，并更改-1+x为x-1。
• +3个字节：糟糕，需要--在后面加一行x-。
• -1字节：在f使用c 47:[]替代[c 47&0]。
• -7个字节：将换行符处理移至w。
• -10字节：内联a="Apple"和p="Pie"在#和使用虚设递归为15的情况。
• -3字节：内嵌w在f。删除和--之间的冗余。x15
• +11个字节：糟糕！我的弦距理论有一个漏洞。通过引入%功能修复。最后进行了一些自动化测试，以确保不再有意外。

f取Int并返回String。

{;f
n=
--
[--
1..
--
n--
]--
>>=
\
--
x->
--
gcd
x
15#
--
x++
--
c
47:
--
[--
]--
;1#
--
x=
--
n!!
--
(x-
--
1--
)--
;3#
--
_=
--
"A\
\p\
\p\
\l\
\e\
\"&
--
0--
;5#
--
_=
--
"P\
\i\
\e\
\"&
--
0--
;--
15#
--
_=
--
3#
--
0++
--
5#
--
0--
;n=
--
d++
--
[--
s++
--
t|
--
s<-
--
n--
,--
t<-
--
[c
9]:
--
d--
]--
;d=
--
(:
--
[--
]--
)--
<$>
--
[c
8..
--
c
0--
]--
;c
x=
--
[--
"9\
\"%
--
0--
,--
"8\
\"%
--
0..
--
]!!
--
x--
;--
[--
a]%
--
_=
--
a--
;x&
--
y=
--
x}

在线尝试！

测试源限制！（第70行被排除在测试之外，因为删除它的换行会导致无输出的无限循环。）

删除了最重要的挤压技巧的版本：

{;f n=[1..n]>>= \x->gcd x 15#x++c 47:[]
;1#x=n!!(x-1)
;3#_="Apple"
;5#_="Pie"
;15#_=3#0++5#0
;n=d++[s++t|s<-n,t<-[c 9]:d]
;d=(:[])<$>[c 8..c 0]
;c x=["9"%0,"8"%0..]!!x
;[a]%_=a
;x&y=x}

怎么运行的

• 这段代码是用Haskell很少使用的缩进不敏感模式编写的，例如通过用包围整个程序来触发{}。由于我实际上是在定义函数而不是整个程序，因此我不确定如何计算字节。我选择防守计数两者的{}S和一个额外的;声明分离器（后者通常是在正常的Haskell模式换行。）
• 使换行符“有意义”的主要技巧是换行符--，它使下一个换行符不可移动，并且如果前一行以运算符结尾（这本身不是行注解的一部分），则也使上一行换行。 。
• 第二个技巧是“字符串间隔”，它是\字符串文字中反斜杠之间的空格序列，用于在可能的缩进的情况下使行连续缩进。带有定界符的字符串间隙将从已解析的字符串中删除。
  • 如果删除了字符串间隙的换行符，它将成为字符串中添加的反斜杠。对于"Apple"，"Pie"这直接显示在输出中。对于"8"和"9"模式匹配是用来给一个错误，如果，所述串具有一个以上的字符。
• 第三个技巧是&and %运算符，它允许在第一个技巧中强制一行以运算符结尾。我们需要它来结束字符串文字，因为\"太宽了，无法追加--。
  • &是一般的，定义为x&y=x。
  • %定义为[a]%y=a，使其可以替换!!0并同时强制其字符串参数必须具有长度1。
• 换行符会带来一个特殊的问题，因为\n似乎不可能将其插入仅包含3个字节的字符串文字中。
  • 因此，使用更容易定义c x=["9"%0,"8"%0..]!!x的方法将Int数字从'9'向下转换为字符。
• 因为show是四个字符，所以必须手动执行数字输出。
  • d是数字字符串的列表"1".."9"。
  • n是["1","2","3",...]使用递归定义的数字表示形式的无限列表d。
• #Int x给定额外的第一个参数15 的gcd，将转换为ApplePie形式x。

Haskell，每行7个字节，339个字节

对于换行符的要求要有意义，这在Haskell中是一项不小的挑战。几乎没有办法插入无法删除的换行符，因此一切都必须使用合法的小语句来完成。

c=cycle
h=head
i=tail
k=[1..]
s=do
 let
  _=0
  _=0
 putStr
t=take
p=print
u=fst
v=snd
z=zip
n=s"\n"
o 5=do
 s"Pie"
 n
o _=n
5%x=o 5
_%x=p x
3!x=do
 s"App"
 s"le"
 o$u x
_!x=do
 let
  y=u x
  z=v x
 y%z
q x=do
 let
  y=u x
  z=v x
 y!z
g[]=s""
g x=do
 q$h x
 g$i x
a=t 3 k
b=t 5 k
l=z$c a
m=z$c b
f n=do
 let
  x=t n
  y=x k
  z=m y
 g$l z

在线尝试！

果冻，3 2字节/行，106 80 56字节

“3
,e
5P
ḍ,
T⁾
ịi
⁾e
AF
ps
,5
⁾¤
pȯ
lµ
,€
⁾Y
”Ỵ
¢Z
¢F
¢v

字符串文字的行和列会换位，因此删除换行符会使它们的顺序混乱。

其余各行是单独的链接/函数，并且包含函数调用（¢），因此只有在消除了函数调用的情况下，也可以将它们串联起来。

在线尝试！

TI-BASIC，每行4个字节

由于目标只是最大行长的最小化，因此某些行的长度超出了需要，但我可以使最长的行最小的是4个字节。因此，如果我合并了可以合并的行而又不超过4个字节，那会使代码更易于阅读。

"APP
Ans→Str1
"LE
Str1+Ans
Ans→Str1
"PIE
Ans→Str2
Input N
1→I
While I≤N
fPart(I/3
not(Ans→A
fPart(I/5
not(Ans→B
If A and B
Then
Str1
Ans+Str2
Disp Ans
Else
If A
Then
Disp Str1
Else
If B
Then
Disp Str2
Else
Disp I
End
End
End
I+1
Ans→I
End

不打高尔夫球

"APPLE"→Str1
"PIE"→Str2
Input "N:",N
For(I,1,N)
remainder(I,3)=0→A
remainder(I,5)=0→B
If A and B:Then
Disp Str1+Str2
Else
If A:Then
Disp Str1
Else
If B:Then
Disp Str2
Else
Disp I
End
End
End
End

关于语言和局限性

TI-BASIC是一种标记化语言，在这种情况下，每个标记均为1个字节，但StrN变量为2个字节。另外，大多数时候您可以省略右括号。该remainder(函数为2个字节，因此使用该函数至少需要5个字节（一个用于函数，两个用于参数，一个用于in的逗号remainder(I,3）。取而代之的是，我使用fPart(和not(函数来缩短它，它们都是1个字节的令牌。另外，您会看到我大量使用了内置变量Ans，因为任何在一行上求值的表达式都会自动存储到该变量中。因此，我可以通过拆分表达式和赋值来节省一些字节。

另一种策略是明显减少字符串分配。我这样做的方法取决于其余代码中的最大行长。一旦确定它是4个字节，就可以在同一行中尽可能多地填充每个字符串，以最大程度地减少所需的分配量。我这样做是为了便于阅读。

此代码中的限制因素是字符串变量的分配以及字符串变量的串联。线Ans→Str1和Str1+Ans两者在总的4个字节。我必须找到一种完全消除字符串变量的方法，以进一步最小化代码中的最大行长。每行最多可以将其他所有内容缩短到3个字节以内。

那里的问题在于对数字变量的赋值，例如1→I。如果不以某种方式提出一种解决方案，即没有长度不超过2个字节的变量的解决方案，您将无法进行进一步的研究。对于这一挑战，这恰好是不可能的。

像这样的二元运算符+需要运算符和左右参数。因此，如果没有此功能，您将无法连接字符串。如果没有字符串连接，则无法在不超过2个字节的行长的情况下显示该程序完成挑战所需的字符串。因此，用这种语言进行此挑战的理论极限是每行3个字节，这是我无法达到的。

C（GCC） ，每行2个字节，374个 368 320 310 262字节

我认为它可以打更多些。反斜杠转义换行符使其显得微不足道。

i\
;\
f\
(\
n\
)\
{\
f\
o\
r\
(\
i\
=\
0\
;\
i\
+\
+\
<\
n\
;\
p\
r\
i\
n\
t\
f\
(\
i\
%\
3\
&\
&\
i\
%\
5\
?\
"\
%\
d\
\\
n\
"\
:\
i\
%\
3\
?\
"\
P\
i\
e\
\\
n\
"\
:\
i\
%\
5\
?\
"\
A\
p\
p\
l\
e\
\\
n\
"\
:\
"\
A\
p\
p\
l\
e\
P\
i\
e\
\\
n\
"\
,\
i\
)\
)\
;\
}

在线尝试！

Python 3，4字节/行，113字节

e=\
exec
def\
f(n\
):i\
=0;\
e('\
pri\
nt(\
i%3\
//2\
*"A\
ppl\
e"+\
i%5\
//4\
*"P\
ie"\
or-\
~i)\
;i+\
=1;\
'*n)

在线尝试！

PHP 7，每行2个字节

(#
c#
.#
r#
.#
e#
.#
a#
.#
t#
.#
e#
.#
_#
.#
f#
.#
u#
.#
n#
.#
c#
.#
t#
.#
i#
.#
o#
.#
n#
)#
(#
'#
'#
,#
g#
.#
l#
.#
o#
.#
b#
.#
a#
.#
l#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
a#
.#
r#
.#
g#
.#
n#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
8#
+#
3#
)#
.#
w#
.#
h#
.#
i#
.#
l#
.#
e#
.#
(#
c#
.#
h#
.#
r#
)#
(#
5#
*#
8#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
i#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
7#
+#
1#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
7#
+#
1#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
8#
+#
4#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
a#
.#
r#
.#
g#
.#
n#
.#
(#
c#
.#
h#
.#
r#
)#
(#
5#
*#
8#
+#
1#
)#
.#
e#
.#
c#
.#
h#
.#
o#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
i#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
+#
1#
)#
.#
3#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
9#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
5#
*#
8#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
i#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
+#
1#
)#
.#
5#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
9#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
i#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
8#
+#
2#
)#
.#
P#
.#
i#
.#
e#
.#
(#
c#
.#
h#
.#
r#
)#
(#
5#
*#
8#
+#
1#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
8#
+#
2#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
5#
*#
8#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
)#
.#
i#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
6#
+#
1#
)#
.#
5#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
9#
)#
.#
A#
.#
p#
.#
p#
.#
l#
.#
e#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
8#
+#
2#
)#
.#
A#
.#
p#
.#
p#
.#
l#
.#
e#
.#
P#
.#
i#
.#
e#
.#
(#
c#
.#
h#
.#
r#
)#
(#
5#
*#
8#
+#
1#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
6#
*#
7#
+#
2#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
4#
*#
8#
+#
2#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
2#
*#
5#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
4#
*#
8#
+#
2#
)#
.#
(#
c#
.#
h#
.#
r#
)#
(#
7#
*#
8#
+#
3#
)#
)#
(#
)#
;#

Aceto，每行1个字节，230个字节

好吧，那可不好写。作为fungoid，Aceto的控制结构在很大程度上依赖于2D性质，但是我们可以解决很多有条件的转义（`）的问题。它们的唯一问题是，无论下一个命令是否存在，它们都会影响下一个命令（所有Aceto程序内部都是正方形），这就是为什么我们需要在某些位置通过在某些点插入空行来对齐该程序。

不能真正使用字符串文字，但是可以使用char文字（在某些地方；同样，我们需要对齐它们）。

&
p
$
L
Q
`
L
p
`
L
d
`
L
Q
`
L
Q
`
L
x
`

L
M
!
%
5
d
$
L
Q
`
L
Q
`
L
p
`
L
d
`
L
Q
`
L
x
`
L
M
!
%
3
d
$
L
p
`
L
d
`
L
x
`

L
M
!
%
*
5
3
d
[
X
`

n
=
0
l
)
@
(
z
i
r
{
J
s
]
d
s
}
d
[
~
£
A
'
d
p
'

l
'

e
'

{
~
£
P
'

i
'
e
'

用调用20，将输出：

1
2
Apple
4
Pie
Apple
7
8
Apple
Pie
11
Apple
13
14
ApplePie
16
17
Apple
19
Pie

所有换行符都必须有意义。必须删除可以断开的换行符，并在不影响输出的情况下连接相邻的行。

这里从来都不是这种情况，因为它是从底部到顶部。

有至少一个地方，我们可以节省2个字节（通过更换`X带有|或#），但我一直在，因为它是因为通过一个比较大的希尔伯特曲线运行相关的运行成本。

我也忽略了使用\r或\r\n换行的隐式要求，因为我认为这是OP的一个无意的错误。如果有修改或评论加强了此要求，我可以毫不费力地更改它，而使用CR换行符即可。

字节数基于Aceto的codegolfing编码；Latin-7，其中£是一个字节。

Perl 5，每行2个字节，182个字节

&
#
{'
Er
0h
|R
hR
o
'#
^#
'I
 O
Ro
3f
+~
'#
.#
(#
p#
|#
Y#
)#
}#
(#
'z
;d
y"
"z
7#
vU
aW
zZ
7#
vU
gW
..
~.
4e
r;
|6
'#
^#
('
xR
~R
KR
fR
QR
/R
$R
cR
QR
/R
vR
UR
%R
xR
$R
'#
.#
4#
))

在线尝试！

Perl的语法非常宽容，因此可以在代码和添加的注释中添加很多空白，这使核心思想相当简单。此代码的主要目的是构建一个包含我们要运行的代码的字符串eval。在Perl中，可以使用带&{...}符号的字符串或变量来调用函数，但是不幸的是，该eval函数不能以这种形式调用，但是evalbytes只要您通过CORE::名称空间调用即可。构建该字符串非常简单，程序直接传递给该调用。字符串是使用换行符作为XOR的一部分构建的，为了构建这些字符串，我使用了此脚本。为了保持此合法性，必须在一些地方放置注释，以便删除换行符将导致代码无法正常工作。

FizzBu​​zz例程取自primo的出色回答。

Perl 5，每行1个字节，172个字节

因此，我（现在）知道这是无效的，因为可以删除许多换行符，但是由于这是我解决该问题的原始方法，因此我添加了它。很高兴看到您可以推广Perl的语法！即使这个问题无效，我也可以单方面享受这个问题。

&
{
(
I
.
'
X
0
o
k
h
~
'
.
(
p
|
Y
)
)
^
'
E
O
0
|
f
s
o
'
}
(
'
x
d
!
K
z
o
Q
U
9
$
Z
o
Q
U
?
v
.
&
%
e
*
$
6
'
^
'

c
~
"
z
f
#
.
/
W
"
c
#
.
/
W
v
U
.
l
x
;
$
4
'
^
p
)

在线尝试！

SmileBASIC，9每行7个字节，159个 155 154 152字节

这是一个非常有趣的挑战。不幸的是，禁止不必要的换行符的规则会引起一些问题，（幸运的是，它不会影响最大的行长。）由于在SB中已正确解析，因此我不得不在A%=I/3和之间添加注释。我可以用一招，留下了一些意见，因为更换同品牌该行无效（它是与使用写入数字符号，我认为，被视为无效号码，而不是一个号码和一个变量名。）A=A%*3A%=I/3A=A%*3AEE3E

A$="App
B$="le
P$="Pie
INPUT N
R=N
WHILE R
INC I
R=I<N
A%=I/3'
A=A%*3'
A=A==I
B%=I/5
E=B%*5
E=E==I'
?A$*A;
?B$*E;
?P$*E;
C=A+E
WHILE!C
C=1?I;
WEND?
WEND

这里最大的限制是获取输入。INPUT x是允许的最简单方法，替代方法是使用输入值定义一个函数，例如，DEF F x但仍为7个字符。进行条件声明也很困难；我想不出比这还短的东西WHILE x。

JavaScript（ES6），每行3个字节

使用全局变量top访问window对象，我们eval从下面的代码中访问该对象：

n=prompt('')
i=0
for(;++i<=n;console.log(i%5?f||i:f+'Pie'))f=i%3?'':'Apple'

您必须在控制台中运行它，因为top沙盒堆栈片段无法访问它。

t//
=//
top
t//
[`\
ev\
al\
`//
]//
(`\
n=\
pr\
om\
pt\
('\
')
i=0
fo\
r(\
;+\
+i\
<=\
n;\
co\
ns\
ol\
e.\
lo\
g(\
i%\
5?\
f|\
|i\
:f\
+'\
Pi\
e'\
))\
f=\
i%\
3?\
''\
:'\
Ap\
pl\
e'\
`)

C＃，每行9个字节，248242230个字节

由于C＃不在乎换行符，因此在几乎每行（感谢ØrjanJohansen）的结尾都需要一个单行注释来遵守规则。该程序期望n作为命令行参数。这里有尽可能多的不可删除的换行符：

class
A//
{//
static
void
Main//
(//
string//
[//
]//
a//
)//
{//
for//
(//
var
i//
=//
0//
;//
i++//
<//
int//
.Parse//
(//
a//
[//
0//
]//
)//
;//
)//
{//
var
s//
=//
""//
;//
if//
(//
i//
%//
3//
==//
0//
)//
s//
+=//
"A"+//
"p"+//
"p"+//
"l"+//
"e"//
;//
if//
(//
i//
%//
5//
==//
0//
)//
s//
+=//
"P"+//
"i"+//
"e"//
;//
if//
(//
s//
==//
""//
)//
s//
=//
$"{i}"//
;//
System//
.//
Console//
.//
Write//
(//
s//
+//
@"
"//
)//
;//
}//
}//
}

但是由于最长的行是9个字节，因此其他行也可以变长，从而减少了一些字节：

class
A{static
void
Main(//
string[//
]a){//
for(var
i=0;i++//
<int.//
Parse(a//
[0]);){//
var 
s="";if//
(i%3==0//
)s+=//
"Apple"//
;if(i%5//
==0)s+=//
"Pie";//
if(s==//
"")s=//
$"{i}";//
System.//
Console//
.Write(//
s+@"
");}}}

Python 2，每行5个字节，93个字节

max6标准已经过时了。

def\
f(n):
 i=0
 \
exec\
'pri\
nt i\
%3/2\
*"Ap\
ple"\
+i%5\
/4*"\
Pie"\
or-~\
i;i+\
=1;'\
*n

在线尝试！

Python 2和3，每行5个字节，100个字节

def\
f(n):
 i=0
 \
exec\
('pr\
int(\
i%3/\
/2*"\
Appl\
e"+i\
%5//\
4*"P\
ie"o\
r-~i\
);i+\
=1;'\
*n)

在线尝试！

JavaScript，每行最多6个字节，528个字节

想法从这里破灭了。

代码从这里撕开。

感谢Anders Kaseorg的帮助g=eval，每行节省了一个字节。

a="n"
a+="="
a+="p"
a+="r"
a+="o"
a+="m"
a+="p"
a+="t"
a+="("
a+="'"
a+="'"
a+=")"
a+=";"
a+="f"
a+="o"
a+="r"
a+="("
a+="i"
a+="="
a+="0"
a+=";"
a+="+"
a+="+"
a+="i"
a+="<"
a+="="
a+="n"
a+=";"
a+="c"
a+="o"
a+="n"
a+="s"
a+="o"
a+="l"
a+="e"
a+="."
a+="l"
a+="o"
a+="g"
a+="("
a+="i"
a+="%"
a+="5"
a+="?"
a+="f"
a+="|"
a+="|"
a+="i"
a+=":"
a+="f"
a+="+"
a+="'"
a+="P"
a+="i"
a+="e"
a+="'"
a+=")"
a+=")"
a+="f"
a+="="
a+="i"
a+="%"
a+="3"
a+="?"
a+="'"
a+="'"
a+=":"
a+="'"
a+="A"
a+="p"
a+="p"
a+="l"
a+="e"
a+="'"
g=eval
g(a)

不分隔：

n=prompt('');for(i=0;++i<=n;console.log(i%5?f||i:f+'Pie'))f=i%3?'':'Apple'

PHP，4字节/行

for#
(#
$z=#
${#
ar.#
gn#
};#
$k#
++<#
$z#
;){#
(#
pr.#
in.#
t_.#
r)#
([#
A.#
p.p#
.le#
][#
$k#
%3#
].[#
Pie#
][#
$k#
%5#
]?:#
$k)#
;(#
pr.#
in.#
t_.#
r)#
("
");}

在线尝试！

APL（Dyalog），每行5个字节

∇f
A←'A'
p←'p'
p,←p
e←'e'
A,←p
l←'l'
A,←l
A,←e
P←'P'
i←'i'
P,←i
P,←e
{O←''
M←3|⍵
M←0=M
O←M/A
M←5|⍵
M←0=M
M←M/P
O,←M
M←⍴O
M←0=M
M←M/⍵
O,←M
⎕←O⍝
}¨⍳⎕
∇

在线尝试！

视网膜，每行4字节

.+
$*      Convert the input number to unary.
1
$`1¶    Count from 1 to the input number.
111
A       Divide by 3.
+`A1
1111    If there was a remainder, restore the original number.
A{5}
AP      If the number is divisible by 3, try to divide by 5. 
.*A     The result ends in `AP` if the number is divisible by 15,
Appl    or in `A` if it is only divisible by 3. Replace everything
l       up to the `A` with `Apple`; multiples of 15 become `AppleP`.
le
1{5}    If the number did not divide by 3, try dividing it by 5 anyway.
P
+`P1    If there was a remainder, restore the original number.
6$*1    Otherwise replace the result with `Pie`,
P+      which also fixes multiples of 15.
Pie     If the number was divisible by neither 3 nor 5,
1+      convert it back to decimal.
$.&

在线尝试！

R，每行10字节，800字节

“有意义的换行符”规则使这一挑战成为现实。当前，这只是将fizzbuzz代码拼写为字符串，然后执行它。

a="x"
a[2]="="
a[3]="y"
a[4]="="
a[5]="1"
a[6]=":"
a[7]="s"
a[8]="c"
a[9]="a"
a[10]="n"
a[11]="("
a[12]=")"
a[13]=";"
a[14]="y"
a[15]="["
a[16]="3"
a[17]="*"
a[18]="x"
a[19]="]"
a[20]="="
a[21]="'"
a[22]="A"
a[23]="p"
a[24]="p"
a[25]="l"
a[26]="e"
a[27]="'"
a[28]=";"
a[29]="y"
a[30]="["
a[31]="5"
a[32]="*"
a[33]="x"
a[34]="]"
a[35]="="
a[36]="'"
a[37]="P"
a[38]="i"
a[39]="e"
a[40]="'"
a[41]=";"
a[42]="y"
a[43]="["
a[44]="1"
a[45]="5"
a[46]="*"
a[47]="x"
a[48]="]"
a[49]="="
a[50]="'"
a[51]="A"
a[52]="p"
a[53]="p"
a[54]="l"
a[55]="e"
a[56]="P"
a[57]="i"
a[58]="e"
a[59]="'"
a[60]=";"
a[61]="w"
a[62]="r"
a[63]="i"
a[64]="t"
a[65]="e"
a[66]="("
a[67]="y"
a[68]="["
a[69]="x"
a[70]="]"
a[71]=","
a[72]="'"
a[73]="'"
a[74]=")"
t=toString
g=gsub
o=", "
l=""
f=t(a)
r=g(o,l,f)
P=parse
p=P(t=r)
eval(p)

在线尝试！

这里是级联ApplePie代码（改编自MickyT的高尔夫在这里）。

x=y=1:scan()
y[3*x]='Apple'
y[5*x]='Pie'
y[15*x]='ApplePie'
write(y[x],'')

以及解析版本的非公开版本：

eval(t=parse(gsub(", ", "", toString(a))))

在这里，我用来toString将符号列表连接a成一个字符串。但是，默认行为是用分隔每个符号,，因此我们呼吁gsub将其替换为null。然后，我们将其传递给parse并eval进行肮脏的工作。

这有可能是有不使用这个字符串解析方法，只是直线上升器具fizzbuzz的方法，但它是用在我看来，for或while或定义function需要比目前的方法更行。

Ruby，10 5字节/行，354 214字节

@NieDzejkob的原始分数为-140字节。

eval\
"pu"\
"ts"\
" ("\
"1."\
".g"\
"et"\
"s."\
"to"\
"_i"\
")."\
"ma"\
"p{"\
"|i"\
"|i"\
"%1"\
"5<"\
"1?"\
":A"\
"pp"\
"le"\
"Pi"\
"e:"\
"i%"\
"5<"\
"1?"\
":P"\
"ie"\
":i"\
"%3"\
"<1"\
"?:"\
"Ap"\
"pl"\
"e:"\
"i}"

怎么运行的

Ruby会?a在同一条语句中自动串联字符串文字的序列（单字符文字如除外）。这意味着x = "a" 'b' "c" %q{d}等同于x = "abcd"。我们使用它来将类似FizzBu​​zz的代码分成更小的字符串以进行调用eval，因为+由于remove-newlines规则，该程序将使程序无效，但是\如果取出换行符，将导致语法错误！

Julia 0.6，每行5个字节，总计168个字节

f=#
n->#
((i,#
a=#
"A"*#
"p"*#
"p"*#
"l"*#
"e",#
p=#
"P"*#
"i"*#
"e"#
)->#
["$i
","$a
","$p
",a*#
p*"
"][#
1+(i#
%3<1#
)+2(#
i%5<#
1)]#
|>[#
print
sin#
][1]#
).(#
1:n)

在线尝试！

所述print带来这不可避免地（AFAICT）转换成每行领土5个字节。

取消高尔夫：

function f_ungolfed(n)
  inner = (i,
           a="Apple",
           p="Pie") -> ["$i\n",
                        "$a\n",
                        "$p\n",
                        a*p*"\n"][
                                    1 + (i%3 < 1) + 2(i%5 < 1)
                                   ] |> [print; sin][1]
  inner.(1:n)
end

*是字符串串联运算符，因此a*p*"\n"格式为“ ApplePie \ n”。|>是函数链接（/ piping）运算符，因此所选字符串将作为参数发送给print。在sin不使用时，它只是存在，因为print需要在数组有显著空白后（使用#技巧后，它会带来的每行最大字节数为6）。

如果只允许将输出作为数组返回，则可以每行最多4个字节来完成：

Julia 0.6，每行4个字节，共152个字节

f=#
n->#
((i#
,a=#
"A"#
*#
"p"#
*#
"p"#
*#
"l"#
*#
"e"#
,p=#
"P"#
*#
"i"#
*#
"e"#
)->#
[i,#
a,p#
,a*#
p][#
1+(#
i%3#
<1#
)+#
2(i#
%5<#
1)]#
).(#
1:n#
)

在线尝试！

该函数接受n并返回包含预期输出的数组。此处的最大行长受到限制n->-Julia需要在一行中将其正确解析为lambda的开头。

Pascal（FPC） -Sew，每行6个字节，348320个字节

var
n,i://
word//
;begin
read//
(n);//
for
i:=1to
n do
if 0=i
mod
15then
write{
$}(//
'A',//
'p',//
'p',//
'l',//
'e',//
'P',//
'i',//
'e',//
#10)//
else
if 0=i
mod
3then
write{
$}(//
'A',//
'p',//
'p',//
'l',//
'e',//
#10)//
else
if 0=i
mod
5then
write{
$}(//
'P',//
'i',//
'e',//
#10)//
else
write{
$}(i//
,#10//
)end.

在线尝试！

利用FPC获得每行6个字节；没有它，结果会更糟。这是最小的行宽，因为之后write必须为;或(（或不必要的空格），因此插入特殊注释可避免这种情况。FPC的功能影响了此答案：

1. // -开始单行注释。
2. 形式的块注释{$<something>...}是编译器指令。如果该指令不存在，则FPC将发出警告（并同时发出警告{$ ...}）。在此程序中，{并$用换行符分隔，删除时将发出警告。
3. -Sew-编译器也暂停警告之后，这样{并$加入停止编译。

Japt，每行3个字节

几乎设法将其减少到每行两个字节，但是如果在其后跟换行符，则映射返回会中断。
FizzBu​​zz实现本身来自规范的FizzBu​​zz线程。

`A
p
p
l
e
`y
Vx
`P
i
e
`y
Xx
ò1\
 Ë\
;W\
pD\
v3\
)+\
Yp\
Dv\
5)\
ªD\
÷

在线尝试！

LOLCODE，每行18个 8字节，共303字节

HAI 1.2
I HAS A…
B ITZ 0
IM IN…
YR L
B R SUM…
OF B AN…
1
MOD OF…
B AN 15
WTF?
OMG 0
VISIBLE…
"Apple"…
"Pie"
OMGWTF
MOD OF…
B AN 5
WTF?
OMG 0
VISIBLE…
"Pie"
OMGWTF
MOD OF…
B AN 3
WTF?
OMG 0
VISIBLE…
"Apple"
OMGWTF
VISIBLE…
B
OIC
OIC
OIC
BOTH…
SAEM B…
AN 100
O RLY?
YA RLY
GTFO
OIC
IM…
OUTTA…
YR L
KTHXBYE

在线尝试！

…感谢ØrjanJohansen，每行-10个字节使用换行符。

Python 2，5字节/行

exec\
'f\
o\
r\
 \
x\
 \
i\
n\
 \
x\
r\
a\
n\
g\
e\
(\
1\
,\
i\
n\
p\
u\
t\
(\
)\
+\
1\
)\
:\
\n\
 \
i\
f\
 \
x\
%\
1\
5\
=\
=\
0\
:\
s\
="\
A\
p\
p\
l\
e\
P\
i\
e"\
\n\
 \
e\
l\
i\
f\
 \
x\
%\
5\
=\
=\
0\
:\
s\
="\
P\
i\
e"\
\n\
 \
e\
l\
i\
f\
 \
x\
%\
3\
=\
=\
0\
:\
s\
="\
A\
p\
p\
l\
e"\
\n\
 \
e\
l\
s\
e\
:\
s\
=\
x\
\n\
 \
p\
r\
i\
n\
t\
(\
s\
)'

在线尝试！

JavaScript（ECMAScript6），每行2个字节

'\
'[
'\
b\
i\
g'
][
'\
c\
o\
n\
s\
t\
r\
u\
c\
t\
o\
r'
][
'\
c\
a\
l\
l'
](
0,
`\
n\
=\
p\
r\
o\
m\
p\
t\
(\
'\
'\
)\
;\
i\
=\
0\
;\
f\
o\
r\
(\
;\
+\
+\
i\
<\
=\
n\
;\
c\
o\
n\
s\
o\
l\
e\
.\
l\
o\
g\
(\
i\
%\
5\
?\
f\
|\
|\
i\
:\
f\
+\
'\
P\
i\
e\
'\
)\
)\
f\
=\
i\
%\
3\
?\
'\
'\
:\
'\
A\
p\
p\
l\
e\
'\
`)
()

详细说明

我们可以使行更短的方法是将代码转换为字符串并转义行尾，这将限制每行2个字节。

所以alert(1)变成

"\
a\
l\
e\
r\
(\
1\
)"

但是现在您的代码是一个字符串，因此我们需要将字符串作为代码执行。我知道至少有四种方法可以将字符串作为代码执行：

1. 评估（代码）。至少要调用5个字节eval(
2. setTimeout（代码，超时）。异步运行函数，但是（可选）如果您传递字符串，它将在内部调用eval。
3. 您可以利用DOM并将代码放入 onclick=""属性中，但是我无法使元素创建部分简短。
4. 调用Function构造函数new Function（）将把您的代码解析为一个匿名函数，您以后可以调用该函数（我使用了此函数）。

所有本地函数里面生活的窗口对象，并在JavaScript中，您可以访问使用对象属性点符号，以便eval()成为window.eval()，或者您也可以访问使用属性括号标记 window['eval']()。您可以利用此eval方法使用前面介绍的方法将in分成多行。但是您仍然必须键入window，一个技巧是，如果您不在框架内，则top变量也是window，因此window.eval变为top.eval（少3个字节）。

w=top
w['eval']

You can shorten the assignment using parenthesis
w=(
top
)
w[
'e\
av\
al'
](
/*string*/
)

因此，这将使代码最少3个字节。为了使代码为2个字节，我使用了new Function(/*string*/);构造函数，但是我必须要创造性地访问它而不必键入它。

首先，Function构造函数允许您省略new关键字来作为函数调用它，这减少了4个字节，但由于另一个原因，它也很重要。调用构造函数的函数仍然返回一个实例，这允许我们转向new Function(code)到Function(code)。另一个重要的事情是Function构造函数有一个call方法，可以使您调用任何函数，但可以覆盖此引用，而Function构造函数本身是一个函数，您可以像调用self一样对其上的方法进行调用Function.call(null, code)。

所有本机函数都是Function构造函数的实例，而javascript中的所有对象都具有构造函数属性。因此，您可以访问任何本地函数（例如）上的Function构造函数alert.constructor，并使用调用方法可以将构造函数作为函数执行。现在，我们有alert.constructor.call（null，code）返回一个函数。

结合之前的理论，我们可以将其转变为 alert['constructor']['call'](null, code)

现在我们只需要找到一个简短的命名函数或方法，所以我在String构造函数中选择big（）方法。所以我可以直接从空字符串访问它"".big

"".big.constructor.call(null, "code")();
''['big']['constructor']['call'](0,'/* code */')() 

然后我把所有东西都弄碎了2个字节

短儿的解释（TLDR）

我正在访问新的Function（code）构造函数来解析字符串，而不是eval（code）。可以通过执行anyFunction在每个本机函数上使用此构造函数。构造函数，例如alert.constructor===Function。我在String.prototype.big中 使用函数/方法，String.prototype.big.constructor.call(null, /*string*/) 但是直接从字符串文字访问它"".big，并将其转换为方 括号。""['big']['constructor']['call'](0, CODE)才能使用打破它\。

点，每行3个字节，共72个字节

V@Y
YUW
Y"L
a
P
S
T
[
`
A
p
p
l
e
`
`
P
i
e
`
]
X
!
*
+
+
i
%
^
3
5
|
i"

在线尝试！

Pip在空白方面非常灵活，因此唯一可行的策略是创建一个字符串，并以一种不需要换行的方式对其进行修改并对其进行评估。

我们创建一个字符串，其中所有其他字符均为换行符，并使用UW（unweave）和一元字符串获取其所有其他字符@（获取第一个元素）来获取：

UW"abcdef"  => ["ace" "bdf"]
@UW"abcdef" => "ace"

的结果@UW应该是我们的ApplePie代码，改编自FizzBu​​zz解决方案此处。如果删除字符串中的任何换行符，则不会导致完整的代码，从而导致语法错误或输出错误。

字符串外还有两个换行符。我们通过使用Y（yank）运算符（在此充当no-op）以及Pip解析大写字母的方式来使这些成为必需：

YUW   => Y UW
YUW Y => Y UW Y
YUWY  => YU WY

因此，如果删除这些换行符，程序将以不同的方式进行解析，并且不会执行应有的功能。

Java 8，每行7个字节，171个字节

一个无效的lambda采取了int。我怀疑这符合有关换行符的要求，但我无法证明这一点，并且用蛮力验证它在我的计算机上大约需要一个月的时间。这样吧。

a->{//
System
s=//
null;//
for(int
i=0;i//
<a;)s//
.out.//
print//
((++i//
%3*(i//
%5)<1//
?(i%3//
<1?//
"App"//
+"le"//
:"")+//
(i%5<//
1?//
"Pie"//
:"")://
i)+//
"\n");}

在线试用

由于该行的注释，很无聊。唯一有趣的是使用null System引用，这似乎是必需的，以便按每行8字节以下的标准输出。另请注意print方法调用是瓶颈。

取消评论，没有评论：

a -> {
    System s = null;
    for (int i = 0; i < a; )
        s.out.print(
            (++i % 3 * (i % 5) < 1 ?
                (i % 3 < 1 ? "App"+"le" : "")
                    + (i % 5 < 1 ? "Pie" : "")
                : i
            ) + "\n"
        );
}