Di recente, qualcuno ha proposto limiti più rigorosi per la lunghezza della linea predefinita di Python:

Chiaramente, nessun programma dovrebbe mai usare più di 80 caratteri per riga, per tutta una serie di ragioni. Innanzitutto, per la leggibilità e la manutenibilità, è importante avere uno standard solido, in modo da poter regolare in modo appropriato la larghezza dei nostri editor di testo. Come vantaggio secondario, il codice può essere facilmente trasferito su supporti che potrebbero avere restrizioni e dove l'aggiunta di interruzioni di riga può essere fonte di distrazione, come stampare pagine per la revisione in una riunione o schede perforate.

Ma 80 caratteri sono troppo alti? Alcuni suggeriscono 79, o addirittura fino a 75, per consentire a un terminale di 80 caratteri di adattarsi al codice con alcune colonne dedicate ai numeri di riga. Chiaramente, in definitiva, è meglio ridurre, poiché i limiti inferiori consentono di utilizzare il codice in più situazioni senza riformattare.

Presentazione dello standard max6

Il tuo obiettivo è trovare e dimostrare la lunghezza minima della linea richiesta dalla tua lingua preferita scrivendo una variante FizzBuzz con il minor numero di caratteri in ogni riga.

Ingresso

Un numero intero, n , tramite qualsiasi metodo desiderato.

Produzione

Stampa i numeri da 1 a n , ( n ≥ 1, n ∈ ℤ) separati da interruzioni di riga, tranne:

• per multipli di 3 stampa "Apple"
• per multipli di 5 stampa "Pie"
• per multipli di 3 e 5 stampa "ApplePie"

punteggio

La lunghezza massima della linea in byte, esclusa l'interruzione di linea (Cr, CrLf, Lf o altra interruzione standard di sistema, specifica, se lo desideri), e la lunghezza totale del codice in byte come tiebreaker.

Regole

Tutte le interruzioni di riga devono essere significative. Le interruzioni di linea che possono essere rimosse e le linee adiacenti direttamente concatenate senza impatto sull'output, devono essere rimosse.

> <> , 1 byte per riga, 243 161 135 byte

-26 byte grazie a Jo King!

Lingue 2D FTW! Anche se scrivere loop e rami usando le istruzioni goto anziché la struttura 2D non è divertente.

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

Provalo online! o guardalo nel parco giochi per pesci !

Il pesce nuota verso il basso lungo il codice, usando goto condizionali per saltare le cose a seconda di ciò che divide l'accumulatore.

Credo che questo soddisfi le specifiche: qualunque sia la nuova riga rimossa, il pesce colpisce sempre l'iniziale v(l'unica istruzione di cambio di direzione presente), quindi il pesce nuota sempre verso il basso nella prima colonna. Pertanto, l'eliminazione di una nuova riga ha l'effetto di rimuovere semplicemente il personaggio successivo dal percorso del pesce e non penso che tu possa rimuovere nessuno dei personaggi senza modificare l'output.

Haskell , 3 byte / linea, 494 471 470 463 453 450 461 byte

MODIFICARE:

• -26 byte: sono state rimosse alcune interruzioni di riga ridondanti e i relativi marcatori di commento associati e modificate -1+xin x-1.
• +3 byte: Oops, --dopo è necessaria una riga aggiuntiva x-.
• -1 byte: in fuso c 47:[]anziché [c 47&0].
• -7 byte: sposta la gestione della nuova riga in w.
• -10 byte: in linea a="Apple"e p="Pie"dentro #e usa una ricorsione fittizia per il caso 15.
• -3 byte: Inline win f. Rimuovere ridondante --tra xe 15.
• +11 byte: Oops di nuovo! La mia teoria del gap delle corde aveva un buco. Risolto introducendo la %funzione. Alla fine ha effettuato alcuni test automatici per assicurarsi che non ci fossero più sorprese.

fprende un Inte restituisce 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}

Provalo online!

Prova le restrizioni sulla fonte!(La riga 70 è esclusa dal test perché la rimozione della sua nuova riga provoca un ciclo infinito senza output.)

Versione con i più importanti trucchi di spremitura rimossi:

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

Come funziona

• Questo codice è scritto nella modalità insensibile di rientro più raramente utilizzata di Haskell, attivata ad esempio circondando un intero programma con {}. Dato che in realtà sto definendo una funzione piuttosto che un intero programma, non sono del tutto sicuro di come contare i byte; Ho scelto di contare in modo difensivo sia la {}s che un extra; separatore di dichiarazioni (quest'ultimo di solito è una nuova riga in modalità Haskell normale).
• Il trucco principale per rendere le nuove righe "significative" sono i --commenti di riga, che rendono la nuova riga non rimovibile, e anche una riga precedente nel caso in cui la riga precedente termina con un carattere operatore (che non fa parte del commento di riga) .
• Il secondo trucco è "gap gap", una sequenza di spazi bianchi tra le \barre rovesciate in letterali stringa, rientrata per le continuazioni di riga con possibile rientro. Un gap di stringa con delimitatori viene rimosso dalla stringa analizzata.
  • Se la nuova riga di un gap di stringa viene rimossa, diventa una barra rovesciata aggiunta nella stringa. Per "Apple"e "Pie"questo si presenta direttamente nell'output. Per "8"e "9"una corrispondenza di modello viene utilizzata per dare un errore se la stringa ha più di un carattere.
• Il terzo trucco sono gli operatori &e %, che consentono di forzare la fine di una linea con un carattere operatore per il primo trucco. Ne abbiamo bisogno per terminare i letterali delle stringhe, perché \"è troppo largo per essere aggiunto --.
  • &è quello generale, definito tale che x&y=x.
  • %è definito in modo tale che [a]%y=a, consentendogli di sostituire !!0e imporre contemporaneamente che il suo argomento stringa deve avere lunghezza 1.
• Il carattere di nuova riga pone un problema speciale, poiché \nsembra impossibile inserirsi in una stringa letterale con solo 3 byte sulla linea.
  • Pertanto, il più facilmente definito c x=["9"%0,"8"%0..]!!xviene utilizzato per convertire da un Intcarattere a, contando dalla cifra '9'verso il basso.
• Poiché showè composto da quattro caratteri, l'output numerico deve essere implementato manualmente.
  • dè un elenco delle stringhe di cifre "1".."9".
  • nè un elenco infinito di rappresentazioni numeriche ["1","2","3",...]definite ricorsivamente usando d.
• #converte un Int xnella sua forma ApplePie dato un primo argomento in più che è il gcddi xcon 15.

Haskell , 7 byte / linea, 339 byte

Il requisito delle interruzioni di linea per essere significativo rende questa una sfida non banale in Haskell. Non ci sono quasi modi per inserire interruzioni di riga che non possono essere rimosse, quindi tutto deve essere fatto con istruzioni legittime minuscole.

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

Provalo online!

Gelatina , 3 2 byte / linea, 106 80 56 byte

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

Le righe e le colonne della stringa letterale vengono trasposte, quindi la rimozione di nuove righe incasina il loro ordine.

Le righe rimanenti sono collegamenti / funzioni separati e contengono chiamate di funzione ( ¢), quindi possono essere concatenate solo se anche le chiamate di funzione vengono eliminate.

Provalo online!

TI-BASIC, 4 byte per riga

Poiché l'obiettivo è solo quello di ridurre al minimo la lunghezza massima della linea, alcune delle linee sono più lunghe di quanto debbano essere, ma il più piccolo che ho potuto fare la linea più lunga era di 4 byte. Pertanto ho ritenuto che avrebbe reso più semplice la lettura del codice se avessi unito le righe che potevano essere combinate senza superare i 4 byte.

"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

Informazioni sulla lingua e limitazioni

TI-BASIC è un linguaggio tokenizzato e, in questo caso, ciascuno dei token è 1 byte ad eccezione delle StrNvariabili, che sono 2 byte. Inoltre, puoi lasciare le parentesi chiuse per la maggior parte del tempo. La remainder(funzione è di 2 byte, quindi il suo utilizzo richiederebbe almeno 5 byte (uno per la funzione, due per gli argomenti e uno per la virgola in remainder(I,3). Invece, ho usato le funzioni fPart(e not(per renderlo più breve, che sono entrambi token da 1 byte. Inoltre, puoi vedere che ho usato Ansabbastanza la variabile incorporata , poiché qualsiasi espressione che viene valutata su una riga da sola viene automaticamente memorizzata in essa. Quindi, posso salvare alcuni byte suddividendo le espressioni e i compiti.

Un'altra strategia era ovviamente quella di ridurre al minimo le assegnazioni di stringhe. Il mio metodo per farlo dipendeva dalla lunghezza massima della linea nel resto del codice. Una volta determinato che era di 4 byte, sono stato in grado di stipare quante più stringhe sulla stessa linea possibile per ridurre al minimo la quantità di incarichi di cui avevo bisogno. L'ho fatto per motivi di leggibilità.

I fattori limitanti in questo codice sono le assegnazioni a variabili stringa e la concatenazione con variabili stringa. Le linee Ans→Str1ed Str1+Ansentrambe sono 4 byte in totale. Dovrei trovare un modo per eliminare completamente le variabili di stringa al fine di minimizzare ulteriormente la lunghezza massima della linea nel mio codice. Tutto il resto può essere ridotto a un massimo di 3 byte o meno per riga.

Il problema qui sta nelle assegnazioni a variabili numeriche, come ad esempio 1→I. Non puoi continuare a giocare a golf senza trovare in qualche modo una soluzione senza variabili che non superino i 2 byte di lunghezza della linea. Sembra impossibile per questa sfida.

Operatori binari come +richiedono il simbolo dell'operatore e gli argomenti sinistro e destro. Quindi, senza questo, non saresti in grado di concatenare le stringhe. Senza la concatenazione di stringhe, non ci sarebbe modo di visualizzare le stringhe richieste per questo programma per completare la sfida senza superare i 2 byte di lunghezza della linea. Pertanto il limite teorico per questa sfida in questa lingua sarebbe di 3 byte per riga, cosa che non sono riuscito a raggiungere.

C (gcc) , 2 byte per riga, 374 368 320 310 262 byte

Presumo che possa essere giocato un po 'di più. Le barre rovesciate che sfuggono alle nuove linee lo rendono in qualche modo banale.

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

Provalo online!

Python 3 , 4 byte / linea, 113 byte

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)

Provalo online!

PHP 7, 2 byte per riga

(#
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 per riga, 230 byte

Beh, non è stato divertente scrivere. Come fungoide, le strutture di controllo di Aceto si basano fortemente sulla sua natura 2D, ma possiamo aggirare il problema con molte, molte fughe condizionali (` ). L'unico problema con questi è che influenzano il comando successivo, indipendentemente dalla sua presenza (tutti i programmi Aceto sono quadrati, internamente), motivo per cui è necessario allineare il programma in alcuni punti inserendo righe vuote in alcuni punti.

I letterali di stringa non possono davvero essere usati, ma i letterali di caratteri possono (in alcuni punti; di nuovo, dobbiamo allinearli).

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

Chiamato con 20, questo stampa:

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

Tutte le interruzioni di riga devono essere significative. Le interruzioni di linea che possono essere rimosse e le linee adiacenti concatenate senza impatto sull'output, devono essere rimosse.

Questo non è mai il caso qui perché va dal basso verso l'alto.

C'è almeno un posto dove possiamo salvare 2 byte (sostituendo il `Xcon un |o# ), ma l'ho tenuto così com'è a causa del costo di runtime associato al passaggio attraverso una curva di Hilbert relativamente grande.

Ho anche ignorato il requisito implicito per l'utilizzo di \ro\r\n newline perché penso che sia un errore involontario da parte del PO. Se c'è una modifica o un commento che rafforza questo requisito, posso cambiarlo senza troppi problemi usando invece le nuove righe CR.

Il bytecount si basa sulla codifica di codegolfing di Aceto; Latin-7, in cui £è un singolo byte.

Perl 5 , 2 byte per riga, 182 byte

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

Provalo online!

La sintassi di Perl è molto tollerante, quindi è possibile aggiungere molte lacune al codice e aggiungere commenti, il che rende l'idea di base abbastanza semplice. L'obiettivo principale di questo codice è quello di creare una stringa contenente il codice che vogliamo eseguire, e evalquesto. In Perl, è possibile chiamare una funzione usando una stringa o una variabile con la &{...}notazione, sfortunatamente, tuttavia, evalnon è richiamabile in questo modulo, ma evalbytesè, fintanto che la chiami tramite . Per mantenerlo valido, è stato necessario inserire alcuni commenti in alcuni punti, in modo che la rimozione delle nuove righe comporti un codice non funzionante.CORE:: spazio nomi. Costruire quella stringa è stato abbastanza semplice e il programma è passato direttamente a questa chiamata. Le stringhe sono costruite utilizzando le nuove linee come parte di XOR, per costruirle ho usato questo script

È stata presa la routine FizzBuzz dall'eccellente risposta di primo .

Perl 5 , 1 byte per riga, 172 byte

Quindi (ora) lo so questo non è valido , perché un sacco di newline può essere rimosso, ma dato che questo era il mio approccio originale al problema, lo sto aggiungendo. È stato divertente vedere fino a che punto puoi spingere la sintassi di Perl! Mi è piaciuto questo problema per suo merito, anche se non è valido.

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

Provalo online!

SmileBASIC, 9 7 byte per riga, 159 155 154 152 152 byte

Questa è stata una sfida davvero divertente. Sfortunatamente, la regola contro le interruzioni di riga non necessarie causa alcuni problemi (anche se fortunatamente non influisce sulla lunghezza massima della linea qui.) Ho dovuto aggiungere commenti tra le righe come A%=I/3e A=A%*3, poiché A%=I/3A=A%*3è analizzata correttamente in SB. Sono stato in grado di usare un trucco per tralasciare alcuni commenti, poiché la sostituzione Acon Erende quella riga non valida (ha qualcosa a che fare con i numeri scritti usando la Enotazione, penso. 3EÈ considerato un numero non valido piuttosto che un numero e un nome di variabile).

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 più grande limitazione qui è ottenere input. INPUT xè il modo più semplice consentito, l'alternativa è quella di definire una funzione con un valore di input simile DEF F xma che sia ancora 7 caratteri. Anche fare una dichiarazione condizionale è difficile; Non riesco a pensare a qualcosa di più corto di WHILE x.

JavaScript (ES6), 3 byte per riga

Utilizza la variabile globale topper accedere windowall'oggetto, da cui abbiamo evalil seguente codice:

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

Dovrai eseguirlo nella console poiché topè inaccessibile da uno snippet di stack in modalità 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 byte per riga, 248 242 230 byte

Dal momento che C # non si preoccupa delle interruzioni di riga, ha bisogno di un commento on-line alla fine di quasi (grazie Ørjan Johansen) ogni riga per rispettare le regole. Questo programma prevede n come argomento della riga di comando. Ecco con quante più nuove righe non cancellabili possibile:

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

Ma poiché la linea più lunga è di 9 byte, anche altre linee possono ottenere così a lungo, tagliando via alcuni byte:

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 byte / linea, 93 byte

Lo standard max6 è già obsoleto.

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

Provalo online!

Python 2 e 3, 5 byte / linea, 100 byte

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

Provalo online!

JavaScript, massimo 6 byte / linea, 528 byte

L'idea è stata strappata da qui .

Codice strappato da qui .

Grazie ad Anders Kaseorg per g=evalaver salvato un byte per riga.

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)

Unseperated:

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

PHP, 4 byte / linea

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

Provalo online!

APL (Dyalog) , 5 byte per riga

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

Provalo online!

Retina , 4 byte / linea

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

Provalo online!

R , 10 byte per riga, 800 byte

La regola delle "interruzioni di linea significative" ha reso questa sfida. Attualmente questo semplicemente scrive il codice fizzbuzz in una stringa e quindi lo esegue.

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)

Provalo online!

Ecco il codice ApplePie concatenato (adattato dal golf di MickyT qui ).

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

E la versione non modificata del codice di analisi:

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

Qui uso toStringper concatenare l'elenco di simboli ain una singola stringa. Tuttavia, il comportamento predefinito consiste nel separare ciascun simbolo con ,, quindi chiamiamo gsubper sostituirli con valori nulli. Quindi lo passiamo a parseeeval per fare il lavoro sporco.

E 'possibile che ci sia un approccio che non fa uso di questo metodo stringa di analisi e solo verso l'alto attrezzi FizzBuzz, ma mi sembra che l'uso foro whileo definire una functionnecessità linee più lunghe rispetto all'approccio attuale.

Rubino, 10 5 byte / linea, 354 214 byte

-140 byte dal punteggio grezzo di @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}"

Come funziona

Ruby will automatically concatenate sequences of string literals (except for single-character literals such as ?a) in the same statement. That means that x = "a" 'b' "c" %q{d} is equivalent to x = "abcd". We use this to split the FizzBuzz-like code into much smaller strings for calling eval with, since + will invalidate the program due to the removing-newlines rule, but the \ will cause syntax errors if the newlines are taken out!

Julia 0.6 , 5 byte per riga, 168 byte in totale

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)

Provalo online!

Il print porta inevitabilmente (afaict) nel territorio di 5 byte per linea.

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

*è l'operatore di concatenazione delle stringhe, quindi a*p*"\n"forma "ApplePie \ n". |>è l'operatore di concatenamento di funzioni (/ piping), quindi la stringa scelta viene inviata come argomento a print. Non sinviene utilizzato, è solo lì perché printdeve essere in un array per avere uno spazio significativo dopo di esso (usando il #trucco dopo porterà il conteggio massimo di byte per riga a 6).

Se è consentito restituire semplicemente l'output come array, è possibile farlo con un massimo di 4 byte per riga:

Julia 0.6 , 4 byte per riga, 152 byte totali

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

Provalo online!

Una funzione che accetta n e restituisce un array contenente l'output previsto. La lunghezza massima della linea qui è limitata da n->- Julia ha bisogno che in una sola riga per analizzarla correttamente come l'inizio di una lambda.

Pascal (FPC) -Sew , 6 byte per riga, 348 320 byte

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.

Provalo online!

Utilizza FPC per ottenere 6 byte per riga; senza di essa, il risultato sarebbe molto peggio. Questa è la larghezza della linea più piccola possibile poiché after writedeve essere uno ;o ((o uno spazio bianco non necessario), quindi un commento speciale viene inserito per evitarlo. Le caratteristiche di FPC che hanno influenzato questa risposta sono:

1. // - avviare commenti di una riga.
2. I commenti di blocco nel modulo {$<something>...}sono direttive del compilatore. Se la direttiva non esiste, FPC emetterà un avviso (e anche su {$ ...}). In questo programma, {e $sono separati da una nuova riga che emetterà l'avviso quando viene eliminato.
3. -Sew- Il compilatore si arresta anche dopo gli avvisi in modo che {e $unito fermano la compilazione.

Japt , 3 byte per riga

Nearly managed to get it down to two bytes per line, but the return from map breaks if it's followed by a newline.
The FizzBuzz implementation itself is from the canonical FizzBuzz thread.

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

Try it online!

LOLCODE, 18 8 bytes per line, 303 bytes 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

Try it online!

-10 bytes per line using the line-continuation character …, thanks to Ørjan Johansen!

Python 2, 5 bytes/line

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

Try it online!

JavaScript (ECMAScript6), 2 bytes per line

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

Long explanation

The way we can make lines shorter is transforming code into a string and escaping the line ends, this will impose a limit of 2bytes per line.

So alert(1) becomes

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

But now your code is a string so we need to execute the string as code. I know at least 4 ways you can execute string as code:

1. eval(code). Which takes at least 5 bytes to call eval(
2. setTimeout(code, timeout). Runs function asyncronously, but optionally if you pass a string it will invoke eval internally.
3. You can take advantage of the DOM and put your code inside a onclick="" attribute, but I could not manage to make the element creation part short.
4. Invoking the Function constructor new Function() will parse your code into a anonymous function which you can call later (I used this).

All the native functions lives inside the window object and in javascript you can access object properties using the dot notation so eval() becomes window.eval(), or you can access properties using the bracket notation window['eval'](). You can take advantage of this to break the eval in multiple lines using the method described before. But you still have to type the window, one trick is that if you're not inside a frame, the top variable is also window, so window.eval becomes top.eval (3 bytes less).

w=top
w['eval']

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

So this will make the code minimum of 3 bytes. To make the code 2 bytes I used the new Function(/*string*/); constructor, but I had to be creative to access it without having to type it.

First, the Function constructor allows you to call it as a function omitting the new keyword, this reduce 4 bytes but it is also important for another reason. Calling the constructor as a function still returns a instance this allows us to turn new Function(code) to Function(code). Another importante thing is that the Function constructor have a call method that allows you to call any function but overriding the this reference, and the Function constructor itself being a function you can call a method on it self like Function.call(null, code).

All native functions are instances of the Function constructor, and all objects in javascript have a constructor property. So you can have access Function constructor on any native function like alert.constructor, and using the call method we can execute the constructor as a function. Now we have alert.constructor.call(null, code) returns a function.

combining the previous thechiniques we can turn it into alert['constructor']['call'](null, code)

Now we just need to find a short named function or method, so I choose the big() method inside the String constructor. So I can access it directly from a empty string "".big

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

Then I just broke every thing in 2 bytes

Shorter explanation (TLDR)

I'm accessing the new Function(code) constructor to parse the string instead of eval(code). This constructor is available at every native function by doing anyFunction.constructor, like alert.constructor===Function. I'm using a function/method inside the String.prototype.big String.prototype.big.constructor.call(null, /*string*/) But accessing it directly from a string literal "".big and turned it to bracket notation. ""['big']['constructor']['call'](0, CODE) to be able to break it using the \.

Pip, 3 bytes per line, 72 bytes total

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

Try it online!

Pip is exceedingly flexible about whitespace, so the only strategy that seems feasible is to create a string, modify it in a way that requires the newlines not to be disturbed, and eval it.

We create a string where every other character is a newline, and take every other character of it using UW (unweave) and unary @ (get first element):

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

The result of @UW should be our ApplePie code, adapted from the FizzBuzz solution here. If any newlines in the string are deleted, this will not result in the full code, giving either a syntax error or incorrect output.

There are still two newlines outside the string. We made these mandatory by using the Y (yank) operator--which here acts as a no-op--together with the way Pip parses runs of uppercase letters:

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

So if these newlines are deleted, the program parses differently and doesn't do what it's supposed to.

Java 8, 7 bytes per line, 171 bytes

A void lambda taking an int. I suspect this obeys the requirement regarding newlines, but I can't prove it, and verifying it by brute force would take about a month on my computer. So it goes.

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

Try It Online

Pretty boring due to the line comments. The only interesting thing here is the use of a null System reference, which seems to be necessary in order to print to standard out in under 8 bytes per line. Note also that the print method call is the bottleneck.

Ungolfed with no comments:

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