Kürzlich hat jemand strengere Grenzwerte für die Standardzeilenlänge von Python vorgeschlagen:

Aus einer ganzen Reihe von Gründen sollte kein Programm mehr als 80 Zeichen pro Zeile verwenden. In erster Linie ist es für die Lesbarkeit und Wartbarkeit wichtig, einen soliden Standard zu haben, damit wir die Breite unserer Texteditoren entsprechend anpassen können. Ein weiterer Vorteil ist, dass Code problemlos auf Medien übertragen werden kann, die möglicherweise Einschränkungen unterliegen, und bei denen das Hinzufügen von Zeilenumbrüchen störend sein kann, z. B. beim Drucken von Seiten zur Überprüfung in einer Besprechung oder auf Lochkarten.

Aber sind 80 Zeichen zu hoch? Einige empfehlen 79 oder sogar nur 75 Zeichen, damit ein 80 Zeichen breites Terminal in den Code mit einigen Spalten für Zeilennummern passt. Letztendlich ist niedriger eindeutig besser, da niedrigere Grenzwerte es ermöglichen, den Code in mehr Situationen ohne Neuformatierung zu verwenden.

Einführung des max6-Standards

Ihr Ziel ist es, die von Ihrer bevorzugten Sprache geforderte Mindestzeilenlänge zu finden und zu demonstrieren, indem Sie eine FizzBuzz-Variante mit der geringsten Anzahl von Zeichen in einer Zeile schreiben.

Eingang

Eine ganze Zahl n über eine beliebige Methode.

Ausgabe

Geben Sie die durch Zeilenumbrüche getrennten Zahlen von 1 bis n ( n ≥ 1, n ∈ ℤ) aus, mit Ausnahme von:

• für ein Vielfaches von 3 drucken "Apple"
• für ein Vielfaches von 5 print "Pie"
• für ein Vielfaches von 3 und 5 drucken "ApplePie"

Wertung

Die maximale Zeilenlänge in Bytes ohne den Zeilenumbruch (Cr, CrLf, Lf oder andere Systemstandardumbrüche, wie gewünscht) und die Gesamtcodelänge in Bytes als Tiebreaker.

Regeln

Alle Zeilenumbrüche müssen aussagekräftig sein. Zeilenumbrüche, die entfernt und benachbarte Zeilen direkt verkettet werden können, ohne dass dies Auswirkungen auf die Ausgabe hat, müssen entfernt werden.

> <> , 1 Byte pro Zeile, 243 161 135 Byte

-26 Bytes dank Jo King!

2D Sprachen FTW! Obwohl das Schreiben von Schleifen und Zweigen mit goto-Anweisungen anstelle der 2D-Struktur keinen Spaß macht.

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

Probieren Sie es online! , oder schau es dir auf dem Fischspielplatz an !

Der Fisch schwimmt entlang des Codes nach unten und verwendet bedingte GOTOS, um Dinge zu überspringen, je nachdem, was den Akkumulator unterteilt.

Ich glaube, dies entspricht der Spezifikation: Unabhängig davon, welche Zeilenumbrüche entfernt werden, trifft der Fisch immer die Initiale v(die einzige Anweisung, die die Richtung ändert), sodass der Fisch in der ersten Spalte immer nach unten schwimmt. Wenn Sie also eine neue Zeile löschen, wird einfach das nächste Zeichen aus dem Pfad des Fisches entfernt, und ich glaube nicht, dass Sie eines der Zeichen entfernen können, ohne die Ausgabe zu ändern.

Haskell , 3 Bytes / Zeile, 494 471 470 463 453 450 461 Bytes

BEARBEITEN:

• -26 Bytes: Entfernt einige redundante Zeilenumbrüche und ihre zugehörigen Kommentarmarkierungen und geändert -1+xin x-1.
• +3 Bytes: Hoppla, benötigte zusätzliche --Zeile danach x-.
• -1 Byte: fWird c 47:[]anstelle von verwendet [c 47&0].
• -7 Bytes: Verschiebt die Zeilenumbruchbehandlung nach w.
• -10 Bytes: Inline a="Apple"und p="Pie"in #und verwende eine Dummy-Rekursion für den Fall 15.
• -3 Bytes: Inline win f. Überflüssiges --zwischen xund entfernen 15.
• +11 Bytes: Hoppla! Meine String Gap Theorie hatte ein Loch. Wird durch die Einführung der %Funktion behoben . Schließlich wurden einige Tests automatisiert, um sicherzustellen, dass es keine Überraschungen mehr gab.

fnimmt ein Intund gibt ein zurück 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}

Probieren Sie es online!

Quellenbeschränkungen testen! (Zeile 70 wird vom Testen ausgeschlossen, da das Entfernen der neuen Zeile eine Endlosschleife ohne Ausgabe verursacht.)

Version mit den wichtigsten Quetschtricks entfernt:

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

Wie es funktioniert

• Dieser Code wird im seltener verwendeten indentation insensitiven Modus von Haskell geschrieben, ausgelöst zB durch Umgeben eines gesamten Programms mit {}. Da ich eigentlich eher eine Funktion als ein ganzes Programm definiere, bin ich mir nicht ganz sicher, wie ich Bytes zählen soll. Ich habe mich dafür entschieden, sowohl das {}s als auch ein zusätzliches ;Deklarationstrennzeichen zu zählen (letzteres ist normalerweise ein Zeilenvorschub im normalen Haskell-Modus).
• Der Haupttrick, um Zeilenumbrüche "aussagekräftig" zu machen, sind Zeilenkommentare --, durch die die nächste Zeile nicht mehr entfernt werden kann, und eine vorherige Zeile, wenn die vorherige Zeile mit einem Operatorzeichen endet (das selbst nicht Teil eines Zeilenkommentars ist). .
• Der zweite Trick ist "String Gaps", eine Folge von Leerzeichen zwischen \Backslashes in String-Literalen, die für Zeilenfortsetzungen mit möglicher Einrückung eingerückt werden. Eine Zeichenfolgenlücke mit Begrenzern wird aus der analysierten Zeichenfolge entfernt.
  • Wenn der Zeilenumbruch einer Zeichenfolge entfernt wird, wird der Zeichenfolge ein Backslash hinzugefügt. Denn "Apple"und "Pie"das zeigt sich direkt in der Ausgabe. For "8"und "9"eine Musterübereinstimmung wird verwendet, um einen Fehler zu ergeben, wenn die Zeichenfolge mehr als ein Zeichen enthält.
• Der dritte Trick sind die Operatoren &und %, mit denen eine Zeile gezwungen wird, in einem Operatorzeichen für den ersten Trick zu enden. Wir brauchen dies, um String-Literale zu beenden, da \"es zu breit ist, um es anzufügen --.
  • &ist die allgemeine, so definiert, dass x&y=x.
  • %ist so definiert, dass [a]%y=a, damit es ersetzen !!0und gleichzeitig erzwingen kann, dass sein Zeichenfolgenargument die Länge 1 haben muss.
• Das Newline-Zeichen stellt ein besonderes Problem dar, da \nes unmöglich zu sein scheint, ein String-Literal mit nur 3 Bytes in der Zeile einzufügen .
  • Daher wird die einfachere Definition c x=["9"%0,"8"%0..]!!xverwendet, um von einem Intin ein Zeichen zu konvertieren , wobei von der Ziffer '9'abwärts gezählt wird.
• Da showes sich um vier Zeichen handelt, muss die Zahlenausgabe von Hand erfolgen.
  • dist eine Liste der Ziffernfolgen "1".."9".
  • nist eine unendliche Liste von Zahlendarstellungen, ["1","2","3",...]die rekursiv mit definiert wurden d.
• #konvertiert ein Int xin sein ApplePie-Formular, wenn ein zusätzliches erstes Argument angegeben wird, das das gcdvon xmit 15 ist.

Haskell , 7 Bytes / Zeile, 339 Bytes

Die Anforderung, dass Zeilenumbrüche sinnvoll sind, macht dies zu einer nicht trivialen Herausforderung in Haskell. Es gibt fast keine Möglichkeit, Zeilenumbrüche einzufügen, die nicht entfernt werden können. Daher muss alles mit rechtmäßig kleinen Anweisungen erfolgen.

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

Probieren Sie es online!

Gelee , 3 2 Bytes / Zeile, 106 80 56 Bytes

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

Zeilen und Spalten des String-Literal werden transponiert, so dass das Entfernen von Zeilenumbrüchen ihre Reihenfolge durcheinander bringt.

Die übrigen Zeilen sind separate Verknüpfungen / Funktionen und enthalten Funktionsaufrufe ( ¢). Sie können also nur verkettet werden, wenn die Funktionsaufrufe ebenfalls entfernt werden.

Probieren Sie es online!

TI-BASIC, 4 Bytes pro Zeile

Da das Ziel nur darin besteht, die maximale Zeilenlänge zu minimieren, sind einige der Zeilen länger als sie sein müssen, aber die kleinste, die ich machen konnte, war die längste Zeile 4 Bytes. Aus diesem Grund hatte ich das Gefühl, es würde den Code leichter lesbar machen, wenn ich die Zeilen zusammenführen würde, die kombiniert werden könnten, ohne 4 Bytes zu überschreiten.

"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

Über die Sprache und Einschränkungen

TI-BASIC ist eine Token-Sprache, und in diesem Fall hat jeder Token ein Byte, mit Ausnahme der StrNVariablen, die 2 Byte lang sind. Außerdem können Sie das Schließen von Klammern die meiste Zeit weglassen. Die remainder(Funktion besteht aus 2 Bytes. Daher sind für ihre Verwendung mindestens 5 Bytes erforderlich (eines für die Funktion, zwei für die Argumente und eines für das Komma in remainder(I,3). Stattdessen habe ich die Funktionen fPart(und not(verwendet, um sie zu verkürzen. Dies sind beide 1-Byte-Token. Sie können auch sehen, dass ich die eingebaute Variable Ansziemlich oft verwendet habe, da jeder Ausdruck, der in einer Zeile selbst ausgewertet wird, automatisch darin gespeichert wird. So kann ich ein paar Bytes sparen, indem ich die Ausdrücke und Zuweisungen aufteile.

Eine andere Strategie bestand darin, die String-Zuweisungen offensichtlich zu minimieren. Meine Methode dazu hing von der maximalen Zeilenlänge im Rest des Codes ab. Nachdem ich festgestellt hatte, dass es sich um 4 Byte handelt, konnte ich so viel von jeder Zeichenfolge in derselben Zeile wie möglich komprimieren, um die Anzahl der benötigten Zuweisungen zu minimieren. Ich habe dies aus Gründen der Lesbarkeit gemacht.

Die einschränkenden Faktoren in diesem Code sind die Zuweisungen zu Zeichenfolgenvariablen und die Verkettung mit Zeichenfolgenvariablen. Die Zeilen Ans→Str1und Str1+Ansbeide sind insgesamt 4 Bytes. Ich müsste einen Weg finden, um String-Variablen vollständig zu eliminieren, um die maximale Zeilenlänge in meinem Code weiter zu minimieren. Alles andere kann auf maximal 3 Byte pro Zeile gekürzt werden.

Das Problem liegt dort in der Zuordnung zu numerischen Variablen, wie z 1→I. Sie können nicht weiter Golf spielen, ohne eine Lösung ohne Variablen zu finden, deren Zeilenlänge 2 Byte nicht überschreitet. Für diese Herausforderung ist das unmöglich.

Binäre Operatoren wie +erfordern das Operator-Symbol und die linken und rechten Argumente. Ohne dies könnten Sie also keine Zeichenfolgen verketten. Ohne die Verkettung von Zeichenfolgen gibt es keine Möglichkeit, die Zeichenfolgen anzuzeigen, die für dieses Programm erforderlich sind, um die Abfrage abzuschließen, ohne die Zeilenlänge von 2 Byte zu überschreiten. Daher wäre die theoretische Grenze für diese Herausforderung in dieser Sprache 3 Bytes pro Zeile, die ich nicht erreichen konnte.

C (gcc) , 2 Bytes pro Zeile, 374 368 320 310 262 Bytes

Ich gehe davon aus, dass man ein bisschen mehr Golf spielen kann. Backslashes, die durch Zeilenumbrüche entstehen, sind so etwas wie 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\
)\
)\
;\
}

Probieren Sie es online!

Python 3 , 4 Bytes / Zeile, 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)

Probieren Sie es online!

PHP 7, 2 Bytes pro Zeile

(#
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 pro Zeile, 230 Byte

Es hat keinen Spaß gemacht, darüber zu schreiben. Als Fungoid hängen Acetos Kontrollstrukturen stark von seiner 2D-Natur ab, aber wir können das mit vielen, vielen bedingten Escapezeichen umgehen ( `). Das einzige Problem bei diesen ist, dass sie sich auf den nächsten Befehl auswirken, unabhängig von dessen Vorhandensein (alle Aceto-Programme sind intern Quadrate), weshalb wir das Programm an einigen Stellen ausrichten müssen, indem wir an einigen Stellen leere Zeilen einfügen.

Zeichenfolgenliterale können nicht wirklich verwendet werden, Zeichenliterale jedoch (an einigen Stellen müssen sie erneut ausgerichtet werden).

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

Aufgerufen mit 20, druckt dies:

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

Alle Zeilenumbrüche müssen aussagekräftig sein. Zeilenumbrüche, die entfernt und benachbarte Zeilen verkettet werden können, ohne die Ausgabe zu beeinträchtigen, müssen entfernt werden.

Dies ist hier nie der Fall, da es von unten nach oben verläuft.

Es gibt mindestens eine Stelle, an der wir 2 Bytes einsparen können (indem wir das `Xdurch ein |oder ersetzen #), aber ich habe es beibehalten, weil die Laufzeitkosten für das Durchlaufen einer relativ großen Hilbert-Kurve so hoch sind.

Ich habe auch die implizite Voraussetzung für die Nutzung ignoriert \roder \r\nZeilenumbrüche , weil ich es ist ein unbeabsichtigter Fehler durch die OP denken. Wenn es eine Änderung oder einen Kommentar gibt, der diese Anforderung verstärkt, kann ich sie ohne großen Aufwand ändern, um stattdessen CR-Zeilenumbrüche zu verwenden.

Der bytecount basiert auf der Codegolfing-Codierung von Aceto. Latin-7, in dem £sich ein einzelnes Byte befindet.

Perl 5 , 2 Bytes pro Zeile, 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#
))

Probieren Sie es online!

Perls Syntax ist sehr nachsichtig, so dass dem Code und den Kommentaren viele Lücken hinzugefügt werden können, was die Kernidee ziemlich einfach macht. Das Hauptziel mit diesem Code ist es, eine Zeichenfolge zu erstellen, die den Code enthält, den wir ausführen möchten, und evales. In Perl ist es möglich, eine Funktion unter Verwendung eines Strings oder einer Variablen mit der &{...}Notation evalaufzurufen. In dieser Form ist sie jedoch nicht aufrufbar evalbytes, solange Sie sie über den CORE::Namespace aufrufen . Das Erstellen dieser Zeichenfolge war ziemlich einfach, und das Programm wird direkt an diesen Aufruf übergeben. Die Zeichenfolgen werden unter Verwendung der Zeilenumbrüche als Teil des XOR erstellt. Um diese zu erstellen, habe ich dieses Skript verwendet. Damit dies gültig bleibt, mussten einige Stellen mit Kommentaren versehen werden, sodass das Entfernen der Zeilenumbrüche zu einem fehlerhaften Code führen würde.

Die FizzBuzz-Routine wurde von primos hervorragender Antwort übernommen .

Perl 5 , 1 Byte pro Zeile, 172 Byte

Ich weiß also (jetzt), dass dies ungültig ist , weil ein paar Zeilenumbrüche entfernt werden können, aber da dies meine ursprüngliche Herangehensweise an das Problem war, füge ich es hinzu. Es hat Spaß gemacht zu sehen, wie weit man Perls Syntax treiben kann! Ich habe dieses Problem aus eigener Kraft genossen, obwohl es ungültig ist.

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

Probieren Sie es online!

SmileBASIC, 9 7 Bytes pro Zeile, 159 155 154 152 Bytes

Dies war eine wirklich lustige Herausforderung. Leider verursacht die Regel gegen unnötige Zeilenumbrüche ein paar Probleme (obwohl sie zum Glück die maximale Zeilenlänge hier nicht beeinflusst.) Ich musste Kommentare zwischen Zeilen wie A%=I/3und einfügen A=A%*3, da diese A%=I/3A=A%*3in SB korrekt analysiert werden. Ich konnte einen Trick verwenden , um einige Kommentare wegzulassen, da ersetzt Amit EMarken , dass Zeile ungültig (Es hat etwas mit Zahlen zu tun geschrieben mit ENotation, denke ich. 3EEine ungültige Nummer gilt eher als eine Zahl und einen Variablennamen.)

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

Die größte Einschränkung besteht darin, Eingaben zu erhalten. INPUT xDies ist der einfachste Weg. Alternativ können Sie eine Funktion mit einem Eingabewert von DEF F x7 Zeichen definieren. Es ist auch schwierig, eine bedingte Aussage zu treffen. Ich kann mir nichts kürzeres als vorstellen WHILE x.

JavaScript (ES6), 3 Bytes pro Zeile

Verwendet die globale Variable, topum auf das windowObjekt zuzugreifen , von dem aus wir evalden folgenden Code verwenden:

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

Sie müssen es in der Konsole ausführen, da topüber ein Stack-Snippet mit Sandbox nicht darauf zugegriffen werden kann.

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 pro Zeile, 248 242 230 Bytes

Da sich C # nicht um Zeilenumbrüche kümmert, muss am Ende fast jeder Zeile (danke Ørjan Johansen) ein Kommentar eingefügt werden, um die Regeln einzuhalten. Dieses Programm erwartet n als Befehlszeilenargument. Hier ist mit so vielen nicht löschbaren Zeilenumbrüchen wie möglich:

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

Da die längste Zeile jedoch 9 Byte lang ist, können auch andere Zeilen so lang werden und einige Byte wegnehmen:

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 / Zeile, 93 Bytes

Der max6-Standard ist bereits veraltet.

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

Probieren Sie es online!

Python 2 und 3, 5 Bytes / Zeile, 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)

Probieren Sie es online!

JavaScript, maximal 6 Bytes / Zeile, 528 Bytes

Idee von hier gerissen .

Code von hier gerissen .

Vielen Dank an Anders Kaseorg für das g=evalSpeichern eines Bytes pro Zeile.

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)

Nicht getrennt:

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

PHP, 4 Bytes / Zeile

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

Probieren Sie es online!

APL (Dyalog) , 5 Bytes pro Zeile

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

Probieren Sie es online!

Netzhaut , 4 Bytes / Zeile

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

Probieren Sie es online!

R , 10 Bytes pro Zeile, 800 Bytes

Die Regel "sinnvolle Zeilenumbrüche" machte dies zu einer Herausforderung. Derzeit wird Fizzbuzz-Code nur in einer Zeichenfolge formuliert und dann ausgeführt.

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)

Probieren Sie es online!

Hier ist der verketteten ApplePie Code (angepasst von MickyT des Golf hier ).

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

Und die unbenutzte Version des Parsing-Codes:

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

Hier verwende ich, toStringum die Liste der Symbole ain einer einzigen Zeichenfolge zu verketten . Das Standardverhalten ist jedoch, jedes Symbol mit zu trennen ,, daher rufen wir gsubauf, sie durch Nullen zu ersetzen. Dann übergeben wir es parseund evalerledigen die Drecksarbeit.

Es ist möglich , dass es ein Ansatz, der diese Zeichenfolge nicht Parsing - Methode nicht verwendet und nur gerade nach oben implementiert FizzBuzz, aber es scheint mir , dass mit foroder whileoder einem bestimmenden functionBedarf mehr Linien als der aktuelle Ansatz.

Ruby, 10 5 Bytes / Zeile, 354 214 Bytes

-140 Bytes aus der Rohbewertung von @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}"

Wie es funktioniert

Ruby verkettet automatisch Sequenzen von String-Literalen (mit Ausnahme von Einzelzeichen-Literalen wie ?a) in derselben Anweisung. Das heißt, das x = "a" 'b' "c" %q{d}ist gleichbedeutend mit x = "abcd". Wir verwenden dies, um den FizzBuzz-ähnlichen Code zum Aufrufen in viel kleinere Zeichenfolgen aufzuteilen eval, da dies +das Programm aufgrund der Regel zum Entfernen von Zeilenumbrüchen ungültig macht, aber \Syntaxfehler verursacht, wenn die Zeilenumbrüche entfernt werden!

Julia 0,6 , 5 Bytes pro Zeile, insgesamt 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)

Probieren Sie es online!

Das printbringt dies unvermeidlich (afaict) in das 5 Bytes pro Zeilengebiet.

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

*ist der String-Verkettungsoperator, a*p*"\n"bildet also "ApplePie \ n". |>ist der Operator für die Funktionsverkettung (/ piping), daher wird der ausgewählte String als Argument an gesendet print. Das sinwird nicht verwendet, es ist nur da, weil printes sich in einem Array befinden muss, um ein signifikantes Leerzeichen danach zu haben (mit dem #Trick danach wird die maximale Byteanzahl pro Zeile auf 6 gebracht).

Wenn die Ausgabe einfach als Array zurückgegeben werden soll, kann dies mit maximal 4 Bytes pro Zeile erfolgen:

Julia 0,6 , 4 Bytes pro Zeile, insgesamt 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#
)

Probieren Sie es online!

Eine Funktion, die n akzeptiert und ein Array mit der erwarteten Ausgabe zurückgibt. Die maximale Zeilenlänge ist hier begrenzt durch n->- Julia benötigt dies in einer einzelnen Zeile, um es richtig als Start eines Lambdas zu analysieren.

Pascal (FPC) -Sew , 6 Bytes pro Zeile, 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.

Probieren Sie es online!

Verwendet FPC, um 6 Bytes pro Zeile zu erhalten. Ohne sie wäre das Ergebnis viel schlechter. Dies ist die kleinstmögliche Linienbreite, da after writeentweder ;oder ((oder ein unnötiges Leerzeichen) sein muss. Daher wird ein spezieller Kommentar eingefügt, um dies zu vermeiden. Die Funktionen von FPC, die diese Antwort beeinflusst haben, sind:

1. // - Einzeilige Kommentare beginnen.
2. Blockkommentare in Formularen {$<something>...}sind Compiler-Direktiven. Wenn die Direktive nicht existiert, gibt FPC eine Warnung aus (und auch an {$ ...}). In diesem Programm werden {und $durch einen Zeilenumbruch getrennt, der beim Löschen die Warnung ausgibt.
3. -Sew- Compiler bleibt auch nach Warnungen stehen, so dass {und $verbunden die Kompilierung stoppt.

Japt , 3 Bytes pro Zeile

Fast geschafft, es auf zwei Bytes pro Zeile zu reduzieren, aber die Rückkehr von der Karte bricht ab, wenn eine neue Zeile folgt.
Die FizzBuzz-Implementierung selbst stammt aus dem kanonischen FizzBuzz-Thread .

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

Probieren Sie es online!

LOLCODE , 18 8 Bytes pro Zeile, insgesamt 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

Probieren Sie es online!

-10 Bytes pro Zeile mit dem …Zeilenfortsetzungszeichen, danke an Ørjan Johansen!

Python 2 , 5 Bytes / Zeile

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

Probieren Sie es online!

JavaScript (ECMAScript6), 2 Bytes pro Zeile

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

Lange Erklärung

Die Art und Weise, wie wir Zeilen kürzer machen können, besteht darin, Code in eine Zeichenfolge umzuwandeln und die Zeilenenden zu maskieren. Dadurch wird ein Limit von 2 Byte pro Zeile festgelegt.

So alert(1)wird es

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

Aber jetzt ist Ihr Code eine Zeichenfolge, daher müssen wir die Zeichenfolge als Code ausführen. Ich kenne mindestens 4 Möglichkeiten, wie Sie einen String als Code ausführen können:

1. eval (Code) . Der Aufruf benötigt mindestens 5 Byteseval(
2. setTimeout (Code, Zeitüberschreitung) . Runs funktionieren asynchron, aber optional wird eval intern aufgerufen, wenn Sie eine Zeichenfolge übergeben.
3. Sie können das DOM nutzen und Ihren Code in ein onclick=""Attribut einfügen , aber ich habe es nicht geschafft, den Elementerstellungsteil kurz zu machen.
4. Durch Aufrufen des Function-Konstruktors new Function () wird Ihr Code in eine anonyme Funktion umgewandelt, die Sie später aufrufen können (ich habe diese Funktion verwendet).

Alle die nativen Funktionen Leben innerhalb des Fenster - Objekt und in Javascript , können die Objekteigenschaften zugreifen , die unter Verwendung von Punktnotation so eval()wird window.eval(), oder Sie können Eigenschaften zugreifen , die unter Verwendung von Dirac-Notation window['eval']() . Sie können dies ausnutzen, um die evalZeilen mit der zuvor beschriebenen Methode in mehrere Zeilen aufzuteilen. Sie müssen das Fenster jedoch noch eingeben eingeben. Ein Trick besteht darin, dass, wenn Sie sich nicht in einem Frame befinden, die obere Variable auch window ist, sodass window.eval zu top.eval wird (3 Byte weniger).

w=top
w['eval']

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

Dadurch wird der Code auf mindestens 3 Byte begrenzt. Um den Code 2 Bytes zu machen, habe ich den new Function(/*string*/);Konstruktor verwendet, aber ich musste kreativ sein, um darauf zuzugreifen, ohne es eingeben zu müssen.

Erstens können Sie den Function- Konstruktor als eine Funktion aufrufen, bei der das neue Schlüsselwort weggelassen wird. Dies verringert die Anzahl der Bytes um 4, ist jedoch auch aus einem anderen Grund wichtig. Der Aufruf der Konstruktor als eine Funktion noch eine Instanz gibt diese uns zu drehen erlaubt new Function(code)zuFunction(code) . Eine andere wichtige Sache ist, dass der Function-Konstruktor eine callMethode hat, mit der Sie jede Funktion aufrufen können, ohne diese Referenz zu überschreiben, und der Function-Konstruktor selbst eine Funktion ist, die Sie wie eine Methode für sich selbst aufrufen können Function.call(null, code).

Alle nativen Funktionen sind Instanzen des Funktionskonstruktors, und alle Objekte in JavaScript verfügen über eine Konstruktoreigenschaft . So können Sie Zugriff auf den Funktionskonstruktor einer beliebigen nativen Funktion alert.constructorhaben und die Funktion verwenden von Call - Methode können wir den Konstruktor als eine Funktion auszuführen. Jetzt haben wir alert.constructor.call (null, code) gibt eine Funktion zurück.

Kombinieren Sie die vorherigen Techniken, die wir daraus machen können alert['constructor']['call'](null, code)

Jetzt müssen wir nur noch eine kurz benannte Funktion oder Methode finden, also wähle ich die big () -Methode im String-Konstruktor. So kann ich direkt von einem leeren String darauf zugreifen"".big

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

Dann habe ich einfach alles in 2 Bytes aufgeteilt

Kurz ähm Erklärung (TLDR)

Ich greife auf den neuen Function (Code) -Konstruktor zu, um die Zeichenfolge anstelle von eval (Code) zu analysieren . Dieser Konstruktor ist für jede native Funktion verfügbar, indem Sie anyFunction ausführen. Konstruktor , wie alert.constructor===Function. Ich verwende eine Funktion / Methode in der Datei String.prototype.big, greife String.prototype.big.constructor.call(null, /*string*/) aber direkt über ein String-Literal darauf zu "".bigund verwende die Klammernotation . ""['big']['constructor']['call'](0, CODE)in der Lage sein, es mit der zu brechen \.

Pip , 3 Bytes pro Zeile, insgesamt 72 Bytes

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

Probieren Sie es online!

Pip ist überaus flexibel in Bezug auf Leerzeichen. Die einzige Strategie, die machbar erscheint, besteht darin, einen String zu erstellen, ihn so zu ändern, dass die Zeilenumbrüche nicht gestört werden, und ihn auszuwerten.

Wir erstellen eine Zeichenfolge, in der jedes andere Zeichen eine neue Zeile ist, und nehmen jedes andere Zeichen mit UW(Uneave) und Unary @(Get First Element):

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

Das Ergebnis @UWsollte unser ApplePie-Code sein, der von der FizzBuzz-Lösung hier angepasst wurde . Wenn Zeilenumbrüche in der Zeichenfolge gelöscht werden, führt dies nicht zum vollständigen Code, was entweder zu einem Syntaxfehler oder zu einer falschen Ausgabe führt.

Außerhalb der Zeichenfolge befinden sich noch zwei Zeilenumbrüche. Wir haben diese obligatorisch gemacht, indem wir den Y(yank) -Operator - der hier als No-Op fungiert - zusammen mit der Art und Weise verwendet haben, wie Pip Großbuchstaben analysiert:

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

Wenn diese Zeilenumbrüche gelöscht werden, wird das Programm anders analysiert und tut nicht das, was es soll.

Java 8, 7 Bytes pro Zeile, 171 Bytes

Ein nichtiger Lambda, der eine int. Ich vermute, dass dies den Anforderungen in Bezug auf Zeilenumbrüche entspricht, aber ich kann es nicht beweisen, und die Überprüfung durch rohe Gewalt würde auf meinem Computer ungefähr einen Monat dauern. So geht es.

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

Probieren Sie es online

Ziemlich langweilig wegen der Zeilenkommentare. Das einzig interessante hier ist die Verwendung einer Nullreferenz System, die notwendig zu sein scheint, um in weniger als 8 Bytes pro Zeile normal auszudrucken. Beachten Sie auch, dass der printMethodenaufruf der Engpass ist.

Ungolfed ohne Kommentare:

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