Recientemente, alguien propuso límites más estrictos para la longitud de línea predeterminada de Python:

Claramente, ningún programa debería usar más de 80 caracteres por línea, por una gran cantidad de razones. En primer lugar, para facilitar la lectura y la mantenibilidad, es importante tener un estándar sólido, para que podamos ajustar el ancho de nuestros editores de texto de manera adecuada. Como beneficio secundario, el código se puede transferir fácilmente a medios que pueden tener restricciones, y donde agregar saltos de línea puede ser una distracción, como imprimir páginas para revisar en una reunión o tarjetas perforadas.

¿Pero son 80 caracteres demasiado altos? Algunos sugieren 79, o incluso tan bajo como 75, para permitir que una terminal de 80 caracteres de ancho se ajuste al código con unas pocas columnas dedicadas a números de línea. Claramente, en última instancia, más bajo es mejor, ya que los límites más bajos permiten que el código se use en más situaciones sin volver a formatear.

Presentamos el estándar max6

Su objetivo es encontrar y demostrar la longitud mínima de línea requerida por su idioma favorito escribiendo una variante de FizzBuzz con el menor número de caracteres en cualquier línea.

Entrada

Un número entero, n , a través de cualquier método deseado.

Salida

Imprima los números del 1 al n , ( n ≥ 1, n ∈ ℤ) separados por saltos de línea, excepto:

• para múltiplos de 3 imprimir "Apple"
• para múltiplos de 5 imprimir "Pie"
• para múltiplos de 3 y 5 imprime "ApplePie"

Tanteo

La longitud máxima de línea en bytes, sin incluir el salto de línea (Cr, CrLf, Lf u otro salto estándar del sistema, especifique, según lo desee), y la longitud total del código en bytes como un desempate.

Reglas

Todos los saltos de línea deben ser significativos. Deben eliminarse los saltos de línea que se pueden eliminar y las líneas adyacentes directamente concatenadas sin un impacto en la salida .

> <> , 1 byte por línea, 243 161 135 bytes

-26 bytes gracias a Jo King!

Lenguajes 2D FTW! Aunque escribir bucles y ramas usando instrucciones goto en lugar de la estructura 2D no es 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

Pruébalo en línea! , o míralo en el parque de peces !

El pez nada hacia abajo a lo largo del código, usando gotos condicionales para saltar cosas dependiendo de lo que divide el acumulador.

Creo que esto cumple con las especificaciones: cualquiera que sea la eliminación de las nuevas líneas, el pez siempre golpea la inicial v(la única instrucción de cambio de dirección presente), por lo que el pez siempre nada hacia abajo en la primera columna. Por lo tanto, eliminar una nueva línea tiene el efecto de simplemente eliminar el siguiente personaje del camino del pez, y no creo que pueda eliminar ninguno de los caracteres sin cambiar la salida.

Haskell , 3 bytes / línea, 494 471 470 463 453 450 461 bytes

EDITAR:

• -26 bytes: se eliminaron algunos saltos de línea redundantes y sus marcadores de comentarios asociados, y se cambió -1+xa x-1.
• +3 bytes: Vaya, se necesitaba una --línea extra después x-.
• -1 byte: en fuso en c 47:[]lugar de [c 47&0].
• -7 bytes: mover el manejo de nueva línea a w.
• -10 bytes: en línea a="Apple"y p="Pie"dentro, #y use una recursión ficticia para el caso 15.
• -3 bytes: wen línea f. Eliminar redundantes --entre xy 15.
• +11 bytes: ¡Vaya de nuevo! Mi teoría de la brecha de cuerdas tenía un agujero. Se solucionó introduciendo la %función. Finalmente realicé algunas pruebas automatizadas para asegurarse de que no hubiera más sorpresas.

ftoma un Inty devuelve un 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}

Pruébalo en línea!

¡Pruebe las restricciones de fuente! (La línea 70 se excluye de la prueba porque eliminar su nueva línea provoca un bucle infinito sin salida).

Versión con los trucos de compresión más importantes eliminados:

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

Cómo funciona

• Este código está escrito en el modo insensible a la sangría más raramente utilizado de Haskell, desencadenado, por ejemplo, al rodear un programa completo con {}. Como en realidad estoy definiendo una función en lugar de un programa completo, no estoy muy seguro de cómo contar bytes; Elegí contar defensivamente tanto el {}s como un ;separador de declaración adicional (este último suele ser una nueva línea en el modo normal de Haskell).
• El truco principal para hacer que las nuevas líneas sean "significativas" son los --comentarios de línea, que hacen que la siguiente nueva línea no sea removible, y también una nueva línea anterior en el caso de que la línea anterior termine en un carácter de operador (que no es parte de un comentario de línea) .
• El segundo truco es "espacios de cadena", una secuencia de espacios en blanco entre las \barras invertidas en literales de cadena, sangrados para continuar las líneas con posible sangría. Un espacio de cadena con delimitadores se elimina de la cadena analizada.
  • Si se elimina la nueva línea de un espacio de cadena, se convierte en una barra invertida adicional en la cadena. Para "Apple"y "Pie"esto se muestra directamente en la salida. For "8"y "9"una coincidencia de patrón se usa para dar un error si la cadena tiene más de un carácter.
• El tercer truco son los operadores &y %, que permiten forzar que una línea termine en un carácter de operador para el primer truco. Necesitamos esto para finalizar los literales de cadena, porque \"es demasiado ancho para agregar --.
  • &es el general, definido de tal manera que x&y=x.
  • %se define de tal manera que le [a]%y=apermite reemplazar !!0y hacer cumplir simultáneamente que su argumento de cadena debe tener una longitud 1.
• El carácter de nueva línea plantea un problema especial, ya que \nparece imposible encajar en un literal de cadena con solo 3 bytes en la línea.
  • Por lo tanto, el más fácil de definir c x=["9"%0,"8"%0..]!!xse utiliza para convertir de un Intcarácter a otro, contando desde el dígito '9'hacia abajo.
• Debido a que showtiene cuatro caracteres, la salida del número debe implementarse a mano.
  • des una lista de las cadenas de dígitos "1".."9".
  • nes una lista infinita de representaciones numéricas ["1","2","3",...]definidas de forma recursiva d.
• #convierte an Int xen su formulario ApplePie dado un primer argumento adicional que es el gcdde xcon 15.

Haskell , 7 bytes / línea, 339 bytes

El requisito de que los saltos de línea sean significativos lo convierte en un desafío no trivial en Haskell. Casi no hay formas de insertar saltos de línea que no se puedan eliminar, por lo que todo debe hacerse con declaraciones legítimamente pequeñas.

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

Pruébalo en línea!

Gelatina , 3 2 bytes / línea, 106 80 56 bytes

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

Las filas y columnas del literal de cadena se transponen, por lo que eliminar las nuevas líneas desordena su orden.

Las líneas restantes son enlaces / funciones separadas y contienen llamadas a funciones ( ¢), por lo que solo se pueden concatenar si también se eliminan las llamadas a funciones.

Pruébalo en línea!

TI-BASIC, 4 bytes por línea

Dado que el objetivo es solo minimizar la longitud máxima de la línea, algunas de las líneas son más largas de lo necesario, pero la más pequeña que pude hacer, la línea más larga fue de 4 bytes. Por lo tanto, sentí que facilitaría la lectura del código si fusionaba las líneas que se podían combinar sin exceder los 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

Sin golf

"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 el lenguaje y las limitaciones

TI-BASIC es un lenguaje tokenizado y, en este caso, cada uno de los tokens tiene 1 byte con la excepción de las StrNvariables, que son 2 bytes. Además, puede dejar de paréntesis de cierre la mayor parte del tiempo. La remainder(función es de 2 bytes, por lo que su uso requeriría al menos 5 bytes (uno para la función, dos para los argumentos y uno para la coma remainder(I,3). En cambio, utilicé las funciones fPart(y not(para hacerlo más corto, que son ambos tokens de 1 byte. Además, puede ver que usé Ansbastante la variable incorporada , ya que cualquier expresión que se evalúa en una línea por sí misma se almacena automáticamente en ella. Entonces, puedo guardar algunos bytes dividiendo las expresiones y las asignaciones.

Otra estrategia era obviamente minimizar las asignaciones de cadenas. Mi método para hacerlo dependía de la longitud máxima de la línea en el resto del código. Una vez que determiné que era de 4 bytes, pude agrupar la mayor cantidad posible de cada cadena en la misma línea para minimizar la cantidad de tareas que necesitaba. Hice esto en aras de la legibilidad.

Los factores limitantes en este código son las asignaciones a variables de cadena y la concatenación con variables de cadena. Las líneas Ans→Str1y Str1+Ansambas son de 4 bytes en total. Tendría que encontrar una manera de eliminar completamente las variables de cadena para minimizar aún más la longitud máxima de línea en mi código. Todo lo demás se puede acortar a un máximo de 3 bytes o menos por línea.

El problema allí radica en las asignaciones a variables numéricas, como 1→I. No puede seguir jugando al golf sin llegar a una solución sin variables que no superen los 2 bytes en la longitud de la línea. Eso resulta imposible para este desafío.

Los operadores binarios como +requieren el símbolo del operador y los argumentos izquierdo y derecho. Entonces, sin esto, no podría concatenar cadenas. Sin la concatenación de cadenas, no habría forma de mostrar las cadenas requeridas para que este programa complete el desafío sin exceder los 2 bytes en la longitud de la línea. Por lo tanto, el límite teórico para este desafío en este lenguaje sería de 3 bytes por línea, que no pude alcanzar.

C (gcc) , 2 bytes por línea, 374 368 320 310 262 bytes

Supongo que se puede jugar un poco más. Las barras invertidas que escapan de las nuevas líneas lo hacen algo 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\
)\
)\
;\
}

Pruébalo en línea!

Python 3 , 4 bytes / línea, 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)

Pruébalo en línea!

PHP 7, 2 bytes por línea

(#
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 línea, 230 bytes

Bueno, eso no fue divertido de escribir. Como fungoide, las estructuras de control de Aceto dependen en gran medida de su naturaleza 2D, pero podemos solucionarlo con muchos, muchos escapes condicionales ( `). El único problema con esos es que afectan el siguiente comando, independientemente de su presencia (todos los programas de Aceto son cuadrados, internamente), por lo que debemos alinear el programa en algunos lugares insertando líneas vacías en algunos puntos.

Los literales de cadena no se pueden usar realmente, pero los literales char sí se pueden (en algunos lugares; nuevamente, necesitamos alinearlos).

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

Llamado con 20, esto imprime:

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

Todos los saltos de línea deben ser significativos. Deben eliminarse los saltos de línea que pueden eliminarse y las líneas adyacentes concatenadas sin afectar la salida.

Este nunca es el caso aquí porque se ejecuta desde abajo hacia arriba.

Hay al menos un lugar donde podemos guardar 2 bytes (reemplazando el `Xcon a |o #), pero lo mantuve como está debido al costo de tiempo de ejecución asociado con la ejecución de una curva de Hilbert relativamente grande.

También ignoré el requisito implícito de usar \ro \r\nlíneas nuevas porque creo que es un error involuntario del OP. Si hay una edición o un comentario que refuerza este requisito, puedo cambiarlo sin muchos problemas para utilizar nuevas líneas CR en su lugar.

El bytecount se basa en la codificación codegolfing de Aceto; Latin-7, en el que £hay un solo byte.

Perl 5 , 2 bytes por línea, 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#
))

Pruébalo en línea!

La sintaxis de Perl es muy indulgente, por lo que se pueden agregar muchas lagunas al código y agregar comentarios, lo que hace que la idea central sea bastante sencilla. El objetivo principal con este código es construir una cadena que contenga el código que queremos ejecutar, y evalesto. En Perl, es posible llamar a una función usando una cadena o variable con la &{...}notación, desafortunadamente, evalno es invocable en esta forma, pero lo evalbyteses, siempre que lo llame a través del CORE::espacio de nombres. Construir esa cadena fue bastante sencillo y el programa se pasa directamente a esta llamada. Las cadenas se crean utilizando las nuevas líneas como parte de XOR, para construirlas utilicé este script. Para mantener esto válido, algunos lugares han tenido que tener comentarios colocados, de modo que eliminar las nuevas líneas resultaría en un código que no funciona.

La rutina FizzBuzz fue tomada de la excelente respuesta de primo .

Perl 5 , 1 byte por línea, 172 bytes

Entonces, (ahora) sé que esto no es válido , porque se pueden eliminar muchas líneas nuevas, pero dado que este era mi enfoque original del problema, lo estoy agregando. ¡Fue divertido ver hasta dónde puede llegar la sintaxis de Perl! Disfruté este problema por mérito propio, aunque no es vá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
)

Pruébalo en línea!

SmileBASIC, 9 7 bytes por línea, 159 155 154 152 bytes

Este fue un desafío muy divertido. Desafortunadamente, la regla contra saltos de línea innecesarios causa algunos problemas (aunque afortunadamente no afecta la longitud máxima de la línea aquí). Tuve que agregar comentarios entre líneas como A%=I/3y A=A%*3, ya que A%=I/3A=A%*3se analiza correctamente en SB. Yo era capaz de utilizar un truco para dejar de lado algunos comentarios, ya que la sustitución Acon Emarcas que no es válida la línea (Tiene algo que ver con los números escritos usando Ela notación, creo. 3ESe considera un número no válido en lugar de un número y un nombre de variable).

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

La mayor limitación aquí es recibir aportes. INPUT xes la forma más sencilla permitida, la alternativa es definir una función con un valor de entrada como DEF F xpero que todavía tiene 7 caracteres. Hacer una declaración condicional también es difícil; No se me ocurre nada más corto que WHILE x.

JavaScript (ES6), 3 bytes por línea

Utiliza la variable global toppara acceder al windowobjeto, de donde tomamos evalel siguiente código:

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

Tendrá que ejecutarlo en la consola ya que topes inaccesible desde un Fragmento de pila sandbox.

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 línea, 248 242 230 bytes

Dado que C # no se preocupa por los saltos de línea, necesita un comentario en línea al final de casi (gracias Ørjan Johansen) cada línea para cumplir con las reglas. Este programa espera n como argumento de línea de comando. Aquí hay tantas líneas nuevas no eliminables como sea posible:

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

Pero como la línea más larga es de 9 bytes, otras líneas también pueden alargarse tanto, lo que reduce algunos 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 / línea, 93 bytes

El estándar max6 ya está obsoleto.

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

Pruébalo en línea!

Python 2 y 3, 5 bytes / línea, 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)

Pruébalo en línea!

JavaScript, máximo de 6 bytes / línea, 528 bytes

Idea arrancada de aquí .

Código arrancado desde aquí .

Gracias a Anders Kaseorg por g=evalguardar un byte por línea.

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)

Sin separar:

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

PHP, 4 bytes / línea

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

Pruébalo en línea!

APL (Dyalog) , 5 bytes por línea

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

Pruébalo en línea!

Retina , 4 bytes / línea

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

Pruébalo en línea!

R , 10 bytes por línea, 800 bytes

La regla de "saltos de línea significativos" hizo que esto fuera un desafío. Actualmente, esto solo explica el código fizzbuzz en una cadena y luego lo ejecuta.

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)

Pruébalo en línea!

Aquí está el código concatenado ApplePie (adaptado del golf de MickyT aquí ).

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

Y la versión no codificada del código de análisis:

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

Aquí uso toStringpara concatenar la lista de símbolos aen una sola cadena. Sin embargo, el comportamiento predeterminado es separar cada símbolo con ,, por lo que llamamos gsubpara reemplazarlos por nulos. Luego lo pasamos parsey evalhacemos el trabajo sucio.

Es posible que haya un enfoque que no utiliza este método de cadena de análisis y justo hacia arriba implementos FizzBuzz, pero me parece que el uso foro el whileo la definición de una functionnecesidades líneas más largas que el enfoque actual.

Ruby, 10 5 bytes / línea, 354 214 bytes

-140 bytes del puntaje bruto 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}"

Cómo funciona

Ruby concatenará automáticamente secuencias de literales de cadena (excepto literales de un solo carácter como ?a) en la misma declaración. Eso significa que x = "a" 'b' "c" %q{d}es equivalente a x = "abcd". Usamos esto para dividir el código similar a FizzBuzz en cadenas mucho más pequeñas para llamar eval, ya +que invalidará el programa debido a la regla de eliminación de líneas nuevas, ¡pero \causará errores de sintaxis si se eliminan las líneas nuevas!

Julia 0.6 , 5 bytes por línea, 168 bytes en total

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)

Pruébalo en línea!

Esto printtrae esto inevitablemente (afaict) a los 5 bytes por territorio de línea.

Sin golf:

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

*es el operador de concatenación de cadenas, por lo que a*p*"\n"forma "ApplePie \ n". |>es el operador de encadenamiento de funciones (/ piping), por lo que la cadena elegida se envía como argumento a print. El sinno se usa, solo está allí porque printdebe estar en una matriz para tener un espacio en blanco significativo después (usar el #truco después de que llevará el recuento máximo de bytes por línea a 6).

Si simplemente se permite devolver la salida como una matriz, se puede hacer con 4 bytes como máximo por línea:

Julia 0.6 , 4 bytes por línea, 152 bytes en total

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

Pruébalo en línea!

Una función que toma n y devuelve una matriz que contiene la salida esperada. La longitud máxima de la línea aquí está limitada por n->: Julia necesita eso en una sola línea para analizarlo correctamente como el inicio de una lambda.

Pascal (FPC) -Sew , 6 bytes por línea, 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.

Pruébalo en línea!

Utiliza FPC para obtener 6 bytes por línea; sin él, el resultado sería mucho peor. Este es el ancho de línea más pequeño posible ya que después writedebe ser ;o ((o espacios en blanco innecesarios), por lo que se inserta un comentario especial para evitar esto. Las características de FPC que influyeron en esta respuesta son:

1. // - comenzando comentarios de una línea.
2. Los comentarios de bloque en forma {$<something>...}son directivas del compilador. Si la directiva no existe, FPC emitirá una advertencia (y {$ ...}también). En este programa, {y $se separan con una nueva línea que emitirá la advertencia cuando se elimine.
3. -Sew- El compilador también se detiene después de las advertencias, por lo que se unió {y $detuvo la compilación.

Japt , 3 bytes por línea

Casi logró reducirlo a dos bytes por línea, pero el retorno del mapa se rompe si es seguido por una nueva línea.
La implementación de FizzBuzz en sí es del hilo canónico de FizzBuzz .

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

Pruébalo en línea!

LOLCODE , 18 8 bytes por línea, 303 bytes en total

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

Pruébalo en línea!

-10 bytes por línea usando el carácter de continuación de línea …, ¡gracias a Ørjan Johansen!

Python 2 , 5 bytes / línea

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

Pruébalo en línea!

JavaScript (ECMAScript6), 2 bytes por línea

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

Larga explicación

La forma en que podemos acortar las líneas es transformando el código en una cadena y escapando de los extremos de la línea, esto impondrá un límite de 2bytes por línea.

Entonces se alert(1)convierte

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

Pero ahora su código es una cadena, por lo que debemos ejecutar la cadena como código. Sé al menos 4 formas en que puede ejecutar una cadena como código:

1. eval (código) . Que toma al menos 5 bytes para llamareval(
2. setTimeout (código, tiempo de espera) . Las ejecuciones funcionan de forma asíncrona, pero opcionalmente si pasa una cadena, invocará eval internamente.
3. Puede aprovechar el DOM y poner su código dentro de un onclick=""atributo, pero no pude hacer que la creación del elemento sea breve.
4. Invocando al constructor de funciones, la nueva función () analizará su código en una función anónima a la que puede llamar más tarde (usé esto).

Todas las funciones nativas de vida dentro de la ventana de objeto y en JavaScript puede acceder a las propiedades del objeto utilizando la notación de puntos por lo eval()convierte en window.eval(), o se puede acceder a las propiedades utilizando el notación de corchetes window['eval']() . Puede aprovechar esto para dividir el evalen varias líneas utilizando el método descrito anteriormente. Pero aún tiene que escribir la ventana , un truco es que si no está dentro de un marco, la variable superior también es ventana, por lo que window.eval se convierte en top.eval (3 bytes menos).

w=top
w['eval']

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

Entonces esto hará que el código sea mínimo de 3 bytes. Para hacer el código de 2 bytes, utilicé el new Function(/*string*/);constructor, pero tuve que ser creativo para acceder a él sin tener que escribirlo.

Primero, el constructor de funciones le permite llamarlo como una función omitiendo la nueva palabra clave, esto reduce 4 bytes, pero también es importante por otra razón. Llamando al constructor como una función todavía devuelve una instancia de esta nos permite convertir new Function(code)a Function(code). Otra cosa importante es que el constructor de funciones tiene un callmétodo que le permite llamar a cualquier función pero anulando esta referencia, y el constructor de funciones en sí es una función a la que puede llamar un método Function.call(null, code).

Todas las funciones nativas son instancias del constructor de funciones, y todos los objetos en javascript tienen una propiedad de constructor . Por lo tanto, puede tener acceso al constructor de funciones en cualquier función nativa como alert.constructor, y utilizando el método de llamada podemos ejecutar el constructor como una función. Ahora tenemos alert.constructor.call (nulo, código) devuelve una función.

combinando los thechiniques anteriores podemos convertirlo en alert['constructor']['call'](null, code)

Ahora solo necesitamos encontrar una función o método con nombre corto, así que elijo el método big () dentro del constructor de cadenas. Entonces puedo acceder directamente desde una cadena vacía"".big

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

Luego rompí todo en 2 bytes

Breve er explicación (TLDR)

Estoy accediendo al nuevo constructor de Función (código) para analizar la cadena en lugar de evaluar (código) . Este constructor está disponible en todas las funciones nativas haciendo anyFunction. constructor , como alert.constructor===Function. Estoy usando una función / método dentro del String.prototype.big String.prototype.big.constructor.call(null, /*string*/) Pero accediendo directamente desde un literal de cadena "".bigy lo convertí en notación de corchetes . ""['big']['constructor']['call'](0, CODE)para poder romperlo usando el \.

Pip , 3 bytes por línea, 72 bytes en total

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

Pruébalo en línea!

Pip es extremadamente flexible sobre los espacios en blanco, por lo que la única estrategia que parece factible es crear una cadena, modificarla de una manera que requiera que las nuevas líneas no se alteren y evaluarla.

Creamos una cadena donde cada otro carácter es una nueva línea, y tomamos todos los demás caracteres usando UW(destejer) y unario @(obtener el primer elemento):

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

El resultado @UWdebería ser nuestro código ApplePie, adaptado de la solución FizzBuzz aquí . Si se eliminan líneas nuevas en la cadena, esto no dará como resultado el código completo, dando un error de sintaxis o una salida incorrecta.

Todavía hay dos nuevas líneas fuera de la cadena. Hicimos esto obligatorio mediante el uso del Yoperador (yank), que aquí actúa como no operativo, junto con la forma en que Pip analiza corridas de letras mayúsculas:

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

Entonces, si se eliminan estas nuevas líneas, el programa se analiza de manera diferente y no hace lo que se supone que debe hacer.

Java 8, 7 bytes por línea, 171 bytes

Un lambda vacío tomando un int. Sospecho que esto obedece el requisito con respecto a las nuevas líneas, pero no puedo probarlo, y verificarlo por la fuerza bruta tomaría aproximadamente un mes en mi computadora. Así que va.

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

Pruébalo en línea

Bastante aburrido debido a los comentarios de línea. Lo único interesante aquí es el uso de una Systemreferencia nula , que parece ser necesaria para imprimir a estándar en menos de 8 bytes por línea. Tenga en cuenta también que la printllamada al método es el cuello de botella.

Ungolfed sin comentarios:

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