Recentemente, alguém propôs limites mais rigorosos para o comprimento da linha padrão do Python:

Claramente, nenhum programa deve usar mais de 80 caracteres por linha, por várias razões. Antes de mais nada, para facilitar a leitura e a manutenção, é importante ter um padrão sólido, para que possamos ajustar a largura de nossos editores de texto adequadamente. Como um benefício secundário, o código pode ser facilmente transferido para a mídia que pode ter restrições e onde a adição de quebras de linha pode ser uma distração, como páginas impressas para revisão em uma reunião ou cartões perfurados.

Mas 80 caracteres são altos demais? Alguns sugerem 79, ou até 75, para permitir que um terminal com 80 caracteres se encaixe no código com algumas colunas dedicadas aos números das linhas. Claramente, em última análise, menor é melhor, pois os limites mais baixos permitem que o código seja usado em mais situações sem reformatação.

Apresentando o padrão max6

Seu objetivo é encontrar e demonstrar o comprimento mínimo de linha exigido pelo seu idioma favorito, escrevendo uma variante do FizzBuzz com o menor número de caracteres em qualquer linha.

Entrada

Um número inteiro, n , através de qualquer método desejado.

Saída

Imprima os números de 1 a n , ( n ≥ 1, n ∈ ℤ) separados por quebras de linha, exceto:

• para múltiplos de 3 impressões "Apple"
• para múltiplos de 5 impressões "Torta"
• para múltiplos de 3 e 5 impressos "ApplePie"

Pontuação

O comprimento máximo da linha em bytes, sem incluir a quebra de linha (Cr, CrLf, Lf ou outra quebra padrão do sistema, especifique, conforme desejado), e o comprimento total do código em bytes como desempatador.

Regras

Todas as quebras de linha devem ser significativas. As quebras de linha que podem ser removidas e as linhas adjacentes diretamente concatenadas sem impacto na saída devem ser removidas.

> <> , 1 byte por linha, 243 161 135 bytes

-26 bytes graças a Jo King!

Linguagens 2D FTW! Embora escrever loops e ramificações usando instruções goto em vez da estrutura 2D não seja divertido.

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

Experimente online! , ou assista no playground de peixes !

O peixe nada para baixo ao longo do código, usando gotos condicionais para pular as coisas, dependendo do que divide o acumulador.

Acredito que isso atenda às especificações: sejam quais forem as novas linhas removidas, o peixe sempre atinge a inicial v(a única instrução de mudança de direção presente); portanto, o peixe sempre nada para baixo na primeira coluna. Assim, excluir uma nova linha tem o efeito de simplesmente remover o próximo caractere do caminho do peixe, e não acho que você possa remover qualquer um dos caracteres sem alterar a saída.

Haskell , 3 bytes / linha, 494 471 470 463 453 450 461 bytes

EDITAR:

• -26 bytes: foram removidas algumas quebras de linha redundantes e seus marcadores de comentários associados e alteradas -1+xpara x-1.
• +3 bytes: Ops, precisava de uma --linha extra depois x-.
• -1 byte: em fuso em c 47:[]vez de [c 47&0].
• -7 bytes: mova o tratamento de nova linha para w.
• -10 bytes: inline a="Apple"e p="Pie"in #e use uma recursão fictícia para o caso 15.
• -3 bytes: inline wem f. Remova redundante --entre xe 15.
• +11 bytes: Opa novamente! Minha teoria da diferença de cordas tinha um buraco. Corrigido através da introdução da %função. Finalmente, fiz alguns testes automatizados para garantir que não houvesse mais surpresas.

fpega um Inte retorna um 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}

Experimente online!

Restrições da fonte de teste! (A linha 70 é excluída do teste porque a remoção de sua nova linha causa um loop infinito sem saída.)

Versão com os truques de aperto mais importantes removidos:

{;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}

Como funciona

• Este código é escrito no modo insensível à indentação mais raramente usado de Haskell, acionado, por exemplo, ao redor de um programa inteiro {}. Como estou definindo uma função em vez de um programa inteiro, não sei bem como contar bytes; Eu escolhi para contar defensivamente tanto o {}s e um extra de ;separador de declaração (o último sendo geralmente uma nova linha no modo Haskell normal.)
• O principal truque para tornar as novas linhas "significativas" são os --comentários de linha, que tornam a próxima nova linha não removível e também uma nova linha anterior, no caso em que a linha anterior termina com um caractere de operador (que não faz parte de um comentário de linha) .
• O segundo truque é "intervalos de string", uma sequência de espaço em branco entre \barras invertidas em literais de string, recuada para continuações de linha com possível recuo. Um espaço de cadeia com delimitadores é removido da cadeia analisada.
  • Se a nova linha de um espaço de cadeia for removida, ela se tornará uma barra invertida adicionada na cadeia. Para "Apple"e "Pie"isso aparece diretamente na saída. Para "8"e "9"uma correspondência de padrão é usada para dar um erro se a sequência tiver mais de um caractere.
• O terceiro truque são os operadores &e %, que permitem forçar uma linha a terminar em um caractere de operador para o primeiro truque. Precisamos disso para finalizar literais de string, porque \"é muito amplo para acrescentar --.
  • &é o geral, definido de tal forma que x&y=x.
  • %é definido de forma que [a]%y=a, permitindo que ele substitua !!0e imponha simultaneamente que seu argumento de cadeia de caracteres tenha o comprimento 1.
• O caractere de nova linha apresenta um problema especial, pois \nparece impossível caber em uma literal de seqüência de caracteres com apenas 3 bytes na linha.
  • Portanto, o mais facilmente definido c x=["9"%0,"8"%0..]!!xé usado para converter de Intum caractere, contando do dígito '9'para baixo.
• Porque show são quatro caracteres, a saída numérica deve ser implementada manualmente.
  • dé uma lista das cadeias de dígitos "1".."9".
  • né uma lista infinita de representações numéricas ["1","2","3",...]definidas recursivamente usando d.
• #converte um Int xem sua forma ApplePie, com um primeiro argumento extra que é o gcdde x15.

Haskell , 7 bytes / linha, 339 bytes

O requisito de quebras de linha sejam significativas faz deste um desafio não trivial em Haskell. Quase não há maneiras de inserir quebras de linha que não possam ser removidas; portanto, tudo deve ser feito com instruções minúsculas.

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

Experimente online!

Gelatina , 3 2 bytes / linha, 106 80 56 bytes

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

Linhas e colunas da cadeia literal são transpostas, portanto, a remoção de novas linhas atrapalha sua ordem.

As linhas restantes são links / funções separados e contêm chamadas de função ( ¢), portanto, elas só podem ser concatenadas se as chamadas de função também forem eliminadas.

Experimente online!

TI-BASIC, 4 bytes por linha

Como o objetivo é apenas minimizar o comprimento máximo da linha, algumas delas são mais longas do que precisam, mas a menor que eu pude criar na linha mais longa foi de 4 bytes. Portanto, achei que seria mais fácil ler o código se mesclasse as linhas que poderiam ser combinadas sem exceder 4 bytes.

"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

Ungolfed

"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

Sobre o idioma e as limitações

O TI-BASIC é uma linguagem tokenizada e, nesse caso, cada um dos tokens tem 1 byte, com exceção das StrNvariáveis, que são 2 bytes. Além disso, você pode deixar de fechar parênteses na maioria das vezes. A remainder(função é de 2 bytes; portanto, para isso, é necessário pelo menos 5 bytes (um para a função, dois para os argumentos e um para a vírgula remainder(I,3). Em vez disso, usei as funções fPart(e not(para torná-lo mais curto, que são ambos tokens de 1 byte. Além disso, você pode ver que eu usei a variável embutidaAns bastante a interna, pois qualquer expressão que é avaliada em uma linha por si só é automaticamente armazenada nela. Portanto, posso economizar alguns bytes dividindo as expressões e atribuições.

Outra estratégia era obviamente minimizar as atribuições de strings. Meu método para fazer isso dependia do comprimento máximo da linha no restante do código. Depois de determinar que tinha 4 bytes, consegui agrupar o máximo de cada sequência na mesma linha possível para minimizar a quantidade de atribuições necessárias. Eu fiz isso por uma questão de legibilidade.

Os fatores limitantes neste código são as atribuições para variáveis ​​de sequência e concatenação com variáveis ​​de sequência. As linhas Ans→Str1eStr1+Ans dois têm 4 bytes no total. Eu precisaria encontrar uma maneira de eliminar completamente as variáveis ​​de string para minimizar ainda mais o comprimento máximo da linha no meu código. Tudo o resto pode ser reduzido para um máximo de 3 bytes ou menos por linha.

O problema está nas atribuições de variáveis ​​numéricas, como 1→I . Você não pode jogar mais isso de alguma forma sem encontrar uma solução sem variáveis ​​que não excedam 2 bytes de comprimento de linha. Isso é impossível para esse desafio.

Operadores binários como +exigem o símbolo do operador e os argumentos esquerdo e direito. Portanto, sem isso, você não seria capaz de concatenar seqüências de caracteres. Sem concatenação de cadeias, não haveria maneira de exibir as cadeias necessárias para este programa concluir o desafio sem exceder 2 bytes no comprimento da linha. Portanto, o limite teórico para esse desafio nesse idioma seria de 3 bytes por linha, o que não consegui atingir.

C (gcc) , 2 bytes por linha, 374 368 320 310 262 bytes

Eu suponho que pode ser jogado um pouco mais. As barras invertidas que escapam das novas linhas o tornam meio trivial.

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

Experimente online!

Python 3 , 4 bytes / linha, 113 bytes

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)

Experimente online!

PHP 7, 2 bytes por linha

(#
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 byte por linha, 230 bytes

Bem, isso não foi divertido de escrever. Como um fungoide, as estruturas de controle do Aceto dependem fortemente de sua natureza 2D, mas podemos contornar isso com muitas, muitas escapadas condicionais (` ). O único problema com eles é que eles afetam o próximo comando, independentemente de sua presença (todos os programas Aceto são quadrados internamente), e é por isso que precisamos alinhar o programa em alguns locais inserindo linhas vazias em alguns pontos.

Os literais de string não podem realmente ser usados, mas os literais de char podem (em alguns lugares; novamente, precisamos alinhá-los).

&
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
'

Chamado com 20, isso imprime:

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

Todas as quebras de linha devem ser significativas. As quebras de linha que podem ser removidas e as linhas adjacentes concatenadas sem impacto na saída devem ser removidas.

Esse nunca é o caso aqui, porque é executado de baixo para cima.

Há pelo menos um lugar onde podemos salvar 2 bytes (substituindo o `X por um |ou# ), mas eu o mantive como está devido ao custo de tempo de execução associado à execução de uma curva de Hilbert relativamente grande.

Eu também ignorei o requisito implícito para usar \r ou \r\nnovas linhas, porque acho que é um erro não intencional do OP. Se houver uma edição ou um comentário que reforce esse requisito, eu posso alterá-lo sem muitos problemas para usar as novas linhas de CR.

O bytecount é baseado na codificação de codegolf da Aceto; Latin-7, no qual £é um único byte.

Perl 5 , 2 bytes por linha, 182 bytes

&
#
{'
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#
))

Experimente online!

A sintaxe do Perl é muito indulgente, portanto, muitas lacunas podem ser adicionadas ao código e aos comentários adicionados, o que torna a idéia central bastante direta. O principal objetivo desse código é criar uma string contendo o código que queremos executar e evalele. No Perl, é possível chamar uma função usando uma string ou variável com a &{...}notação, infelizmente, no entanto, evalnão é possível chamar dessa forma, mas evalbytesé, desde que você a chame por meio do . Para manter isso válido, alguns locais tiveram que colocar comentários, para que a remoção das novas linhas resultasse em código que não funcionava.CORE:: namespace. A criação dessa sequência foi bastante direta e o programa é passado diretamente para esta chamada. As strings são construídas utilizando as novas linhas como parte do XOR, para construir essas eu usei esse script

A rotina do FizzBuzz foi retirada da excelente resposta do primo .

Perl 5 , 1 byte por linha, 172 bytes

Então, agora eu sei que isso é inválido , porque várias linhas novas podem ser removidas, mas como essa foi minha abordagem original para o problema, eu a adicionei. Foi divertido ver até onde você consegue empurrar a sintaxe do Perl! Eu gostei desse problema por mérito próprio, embora seja inválido.

&
{
(
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
)

Experimente online!

SmileBASIC, 9 7 bytes por linha, 159 155 154 152 152 bytes

Este foi um desafio muito divertido. Infelizmente, a regra contra quebras de linha desnecessárias causa alguns problemas (embora felizmente não afete o comprimento máximo da linha aqui.) Eu tive que adicionar comentários entre as linhas como A%=I/3e A=A%*3, uma vez que A%=I/3A=A%*3é analisado corretamente no SB. Eu pude usar um truque para deixar de fora alguns comentários, pois a substituição Apor Einvalida essa linha (isso tem algo a ver com números escritos usando Enotação, eu acho. 3EÉ considerado um número inválido em vez de um número e um nome de variável).

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

A maior limitação aqui é obter informações. INPUT xé a maneira mais simples permitida, a alternativa é definir uma função com um valor de entrada como, DEF F xmas que ainda tem 7 caracteres. Fazer uma declaração condicional também é difícil; Não consigo pensar em nada mais curto que WHILE x.

JavaScript (ES6), 3 bytes por linha

Usa a variável global toppara acessar o windowobjeto, a partir do qualeval o seguinte código:

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

Você precisará executá-lo no console, pois topé inacessível a partir de um snippet de pilha na caixa de areia.

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 bytes por linha, 248 242 230 bytes

Como o C # não se importa com quebras de linha, ele precisa de um comentário on-line no final de quase (obrigado Ørjan Johansen) todas as linhas para cumprir as regras. Este programa espera n como um argumento de linha de comando. Aqui está o maior número possível de novas linhas não excluídas:

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//
+//
@"
"//
)//
;//
}//
}//
}

Mas como a linha mais longa tem 9 bytes, outras linhas também podem ter esse comprimento, eliminando alguns bytes:

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 bytes / linha, 93 bytes

O padrão max6 já está obsoleto.

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

Experimente online!

Python 2 e 3, 5 bytes / linha, 100 bytes

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

Experimente online!

JavaScript, máximo de 6 bytes / linha, 528 bytes

Idéia arrancada daqui .

Código extraído daqui .

Agradecemos a Anders Kaseorg por g=evalsalvar um byte por linha.

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ão separados:

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

PHP, 4 bytes / linha

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

Experimente online!

APL (Dyalog) , 5 bytes por linha

∇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⍝
}¨⍳⎕
∇

Experimente online!

Retina , 4 bytes / linha

.+
$*      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.
$.&

Experimente online!

R , 10 bytes por linha, 800 bytes

A regra "quebras de linha significativas" tornou esse desafio. Atualmente, isso apenas explica o código do fizzbuzz em uma string e depois o executa.

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)

Experimente online!

Aqui está o código ApplePie concatenado (adaptado do golfe de MickyT aqui ).

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

E a versão não destruída do código de análise:

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

Aqui eu uso toStringpara concatenar a lista de símbolos aem uma única string. No entanto, o comportamento padrão é separar cada símbolo com ,, portanto, chamamos gsubpara substituí-los por nulos. Então passamos para parseeeval fazemos o trabalho sujo.

É possível que exista uma abordagem que não use esse método de análise de string e apenas implemente o fizzbuzz, mas parece-me que usar forouwhile ou definir um functionnecessidades linhas mais longas do que a abordagem atual.

Rubi, 10 5 bytes / linha, 354 214 bytes

-140 bytes da pontuação bruta de @NieDzejkob.

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}"

Como funciona

O Ruby concatenará automaticamente sequências de literais de cadeia de caracteres (exceto literais de um caractere como ?a) na mesma instrução. Isso significa que x = "a" 'b' "c" %q{d}é equivalente a x = "abcd". Usamos isso para dividir o código do FizzBuzz em sequências muito menores para chamar eval, pois +invalidará o programa devido à regra de remoção de novas linhas, mas \causará erros de sintaxe se as novas linhas forem removidas!

Julia 0,6 , 5 bytes por linha, total de 168 bytes

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)

Experimente online!

o print traz isso inevitavelmente (em conflito) para o território de 5 bytes por linha.

Ungolfed:

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

*é o operador de concatenação de strings e a*p*"\n"forma "ApplePie \ n". |>é o operador de encadeamento de funções (/ piping), portanto, a sequência escolhida é enviada como argumento para print. O sinnão é usado, ele está lá porque printprecisa estar em uma matriz para ter um espaço em branco significativo depois dele (usar o #truque depois trará a contagem máxima de bytes por linha para 6).

Se simplesmente é permitido retornar a saída como uma matriz, isso pode ser feito com 4 bytes no máximo por linha:

Julia 0,6 , 4 bytes por linha, total de 152 bytes

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#
)

Experimente online!

Uma função que pega n e retorna uma matriz que contém a saída esperada. O comprimento máximo da linha aqui é limitado por n->- Julia precisa disso em uma única linha para analisá-la corretamente como o início de uma lambda.

Pascal (FPC) -Sew , 6 bytes por linha, 348 320 bytes

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.

Experimente online!

Utiliza o FPC para obter 6 bytes por linha; sem ele, o resultado seria muito pior. Essa é a menor largura de linha possível, pois depois writedeve ser ;ou ((ou espaço em branco desnecessário); portanto, um comentário especial é inserido para evitar isso. Os recursos do FPC que influenciaram esta resposta são:

1. // - iniciando comentários de uma linha.
2. Bloquear comentários no formulário {$<something>...} são diretivas do compilador. Se a diretiva não existir, o FPC emitirá um aviso (e {$ ...}também). Neste programa, {e $são separados por uma nova linha que emitirá o aviso quando excluído.
3. -Sew- O compilador também pára após os avisos para que, {e $unidos, parem a compilação.

Japt , 3 bytes por linha

Quase consegui reduzi-lo a dois bytes por linha, mas o retorno do mapa é interrompido se for seguido por uma nova linha.
A implementação do FizzBuzz em si é do segmento canônico do FizzBuzz .

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

Experimente online!

LOLCODE , 18 8 bytes por linha, total de 303 bytes

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

Experimente online!

-10 bytes por linha usando o caractere de continuação de linha …, graças a Ørjan Johansen!

Python 2 , 5 bytes / linha

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\
)'

Experimente online!

JavaScript (ECMAScript6), 2 bytes por linha

'\
'[
'\
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\
'\
`)
()

Explicação longa

A maneira como podemos tornar as linhas mais curtas é transformar o código em uma string e escapar do final da linha, isso impõe um limite de 2 bytes por linha.

Então alert(1)se torna

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

Mas agora seu código é uma string, então precisamos executá-la como código. Eu sei pelo menos 4 maneiras que você pode executar seqüência de caracteres como código:

1. eval (código) . O que leva pelo menos 5 bytes para chamareval(
2. setTimeout (código, tempo limite) . Executa a função de forma assíncrona, mas, opcionalmente, se você passar uma string, ela chamará eval internamente.
3. Você pode tirar proveito do DOM e colocar seu código dentro de um onclick="" atributo, mas não consegui tornar a criação do elemento curta.
4. Chamar o construtor Function new Function () analisará seu código em uma função anônima que você pode chamar mais tarde (usei isso).

Todas as funções nativas vidas dentro da janela de objeto e em javascript você pode acessar propriedades do objeto usando a notação de ponto para que eval()se torne window.eval(), ou você pode acessar as propriedades usando a notação de colchetes window['eval']() . Você pode tirar vantagem disso para quebrar as evalvárias linhas usando o método descrito anteriormente. Mas você ainda precisa digitar o janela , um truque é que, se você não estiver dentro de um quadro, a variável top também será window, então window.eval se tornará top.eval (3 bytes a menos).

w=top
w['eval']

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

Portanto, isso tornará o código mínimo de 3 bytes. Para tornar o código 2 bytes, usei onew Function(/*string*/); construtor, mas tive que ser criativo para acessá-lo sem precisar digitá-lo.

Primeiro, o construtor Function permite chamá-lo como uma função que omite a nova palavra-chave; isso reduz 4 bytes, mas também é importante por outro motivo. Chamar o construtor como uma função ainda retorna uma instância que nos permite ativarnew Function(code) a Function(code). Outra coisa importante é que o construtor Function tenha umcall método que permite que você chame qualquer função, mas substitui a referência desta, e o próprio construtor Function é uma função que você pode chamar por si próprio.Function.call(null, code) .

Todas as funções nativas são instâncias do construtor Function e todos os objetos em javascript possuem uma propriedade construtora . Assim, você pode ter acesso ao construtor Function em qualquer função nativa como alert.constructor, e usando a chamada método de , podemos executar o construtor como uma função. Agora temos alert.constructor.call (null, code) retorna uma função.

combinando as técnicas anteriores, podemos transformá-lo em alert['constructor']['call'](null, code)

Agora só precisamos encontrar uma função ou método nomeado curto, então escolho o método big () dentro do construtor String. Para acessá-lo diretamente de uma string vazia"".big

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

Então eu apenas quebrei tudo em 2 bytes

Curto er explicação (TLDR)

Estou acessando o novo construtor Function (code) para analisar a string em vez de eval (code) . Esse construtor está disponível em todas as funções nativas executando anyFunction. construtor , como alert.constructor===Function. Eu estou usando uma função / método dentro do String.prototype.big String.prototype.big.constructor.call(null, /*string*/) Mas acessando-o diretamente de um literal de seqüência de caracteres "".bige o transformou em notação de colchete . ""['big']['constructor']['call'](0, CODE)para poder quebrá-lo usando o \.

Pip , 3 bytes por linha, total de 72 bytes

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

Experimente online!

O Pip é extremamente flexível em relação ao espaço em branco; portanto, a única estratégia que parece viável é criar uma string, modificá-la de uma maneira que exija que as novas linhas não sejam perturbadas e avaliá-la.

Criamos uma string em que todos os outros caracteres são uma nova linha e pegamos todos os outros caracteres usando UW(desenrolar) e unário @(obter o primeiro elemento):

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

O resultado @UWdeve ser o nosso código ApplePie, adaptado da solução FizzBuzz aqui . Se alguma nova linha da string for excluída, isso não resultará no código completo, resultando em erro de sintaxe ou saída incorreta.

Ainda existem duas novas linhas fora da string. Tornamos isso obrigatório usando o Yoperador (yank) - que aqui atua como não operacional - junto com a maneira como Pip analisa as letras maiúsculas:

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

Portanto, se essas novas linhas são excluídas, o programa analisa de maneira diferente e não faz o que deveria.

Java 8, 7 bytes por linha, 171 bytes

Um lambda vazio tomando uma int. Suspeito que isso obedeça ao requisito referente às novas linhas, mas não posso prová-lo, e a verificação por força bruta levaria cerca de um mês no meu computador. Assim vai.

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

Experimente Online

Muito chato devido aos comentários da linha. A única coisa interessante aqui é o uso de um valor nuloSystem referência , que parece ser necessária para imprimir com padrão abaixo de 8 bytes por linha. Observe também que a printchamada do método é o gargalo.

Ungolfed sem comentários:

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