Récemment, quelqu'un a proposé des limites plus strictes pour la longueur de ligne par défaut de Python:

De toute évidence, aucun programme ne devrait jamais utiliser plus de 80 caractères par ligne, pour une multitude de raisons. Tout d'abord, pour la lisibilité et la maintenabilité, il est important d'avoir une norme solide, afin que nous puissions ajuster la largeur de nos éditeurs de texte de manière appropriée. Comme avantage secondaire, le code peut facilement être transféré sur des supports qui peuvent avoir des restrictions et où l'ajout de sauts de ligne peut être gênant, comme imprimer des pages à réviser lors d'une réunion ou des cartes perforées.

Mais 80 caractères sont-ils trop élevés? Certains suggèrent 79, ou même aussi bas que 75, pour permettre à un terminal de 80 caractères de large de s'adapter au code avec quelques colonnes consacrées aux numéros de ligne. Clairement, en fin de compte, une valeur inférieure est meilleure, car des limites inférieures permettent au code d'être utilisé dans plus de situations sans reformater.

Présentation de la norme max6

Votre objectif est de trouver et de démontrer la longueur de ligne minimale requise par votre langue préférée en écrivant une variante FizzBuzz avec le moins de caractères dans une ligne.

Contribution

Un entier, n , via n'importe quelle méthode souhaitée.

Sortie

Imprimez les nombres de 1 à n , ( n ≥ 1, n ∈ ℤ) séparés par des sauts de ligne, sauf:

• pour des multiples de 3 imprimés "Apple"
• pour des multiples de 5 imprimer "Pie"
• pour les multiples de 3 et 5 imprimer "ApplePie"

Notation

La longueur de ligne maximale en octets, à l'exclusion du saut de ligne (Cr, CrLf, Lf ou autre saut standard du système, spécifiez, si vous le souhaitez), et la longueur totale du code en octets en tant que bris d'égalité.

Règles

Tous les sauts de ligne doivent être significatifs. Les sauts de ligne qui peuvent être supprimés et les lignes adjacentes directement concaténées sans impact sur la sortie doivent être supprimés.

> <> , 1 octet par ligne, 243 161 135 octets

-26 octets grâce à Jo King!

Langues 2D FTW! Bien que l'écriture de boucles et de branches à l'aide d'instructions goto au lieu de la structure 2D ne soit pas amusante.

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

Essayez-le en ligne! , ou regardez-le au terrain de pêche !

Le poisson nage vers le bas le long du code, en utilisant des gotos conditionnels pour sauter des choses en fonction de ce qui divise l'accumulateur.

Je crois que cela répond à la spécification: quelles que soient les nouvelles lignes supprimées, le poisson frappe toujours l'initiale v(la seule instruction de changement de direction présente), donc le poisson nage toujours vers le bas dans la première colonne. Ainsi, la suppression d'une nouvelle ligne a pour effet de supprimer simplement le caractère suivant du chemin du poisson, et je ne pense pas que vous puissiez supprimer l'un des caractères sans modifier la sortie.

Haskell , 3 octets / ligne, 494 471 470 463 453 450 461 octets

MODIFIER:

• -26 octets: Suppression de quelques sauts de ligne redondants et de leurs marqueurs de commentaire associés, et modification -1+xen x-1.
• +3 octets: Oups, il fallait une --ligne supplémentaire après x-.
• -1 octet: futilisé c 47:[]au lieu de [c 47&0].
• -7 octets: déplace la gestion de la nouvelle ligne vers w.
• -10 octets: Inline a="Apple"et p="Pie"in #et utilisez une récursivité factice pour le 15 cas.
• -3 octets: Inline win f. Supprimer la redondance --entre xet 15.
• +11 octets: Oups encore! Ma théorie de l'écart des cordes avait un trou. Corrigé en introduisant la %fonction. Enfin, nous avons effectué des tests automatisés pour nous assurer qu'il n'y avait plus de surprises.

fprend un Intet retourne 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}

Essayez-le en ligne!

Testez les restrictions de source! (La ligne 70 est exclue du test car la suppression de sa nouvelle ligne provoque une boucle infinie sans sortie.)

Version avec les astuces de compression les plus importantes supprimées:

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

Comment ça marche

• Ce code est écrit dans le mode insensible à l'indentation le plus rarement utilisé de Haskell, déclenché par exemple en entourant un programme entier avec {}. Puisque je suis en train de définir une fonction plutôt qu'un programme entier, je ne sais pas trop comment compter les octets; J'ai choisi de compter défensivement à la fois le {}s et un ;séparateur de déclaration supplémentaire (ce dernier étant généralement une nouvelle ligne en mode Haskell normal.)
• L'astuce principale pour rendre les retours à la ligne «significatifs» est les --commentaires de ligne, qui rendent le prochain retour à la ligne non amovible, ainsi qu'un retour à la ligne précédent dans le cas où la ligne précédente se termine par un caractère opérateur (qui ne fait pas lui-même partie d'un commentaire de ligne) .
• La deuxième astuce est "les écarts de chaîne", une séquence d'espaces entre les \barres obliques inverses dans les littéraux de chaîne, en retrait pour les continuations de ligne avec une indentation possible. Un écart de chaîne avec des délimiteurs est supprimé de la chaîne analysée.
  • Si la nouvelle ligne d'un espace de chaîne est supprimée, elle devient une barre oblique inverse ajoutée dans la chaîne. Pour "Apple"et "Pie"cela apparaît directement dans la sortie. Pour "8"et "9"une correspondance de modèle est utilisée pour donner une erreur si la chaîne a plus d'un caractère.
• La troisième astuce est les opérateurs &et %, qui permettent de forcer une ligne à se terminer par un caractère d'opérateur pour la première astuce. Nous en avons besoin pour mettre fin aux littéraux de chaîne, car ils \"sont trop larges pour être ajoutés --.
  • &est le général, défini tel que x&y=x.
  • %est défini de telle sorte que [a]%y=a, ce qui lui permet de remplacer !!0et d'imposer simultanément que son argument de chaîne doit avoir une longueur de 1.
• Le caractère de nouvelle ligne pose un problème spécial, car il \nsemble impossible de tenir dans un littéral de chaîne avec seulement 3 octets sur la ligne.
  • Par conséquent, le plus facilement défini c x=["9"%0,"8"%0..]!!xest utilisé pour convertir d' Intun caractère en un caractère, en comptant du chiffre '9'vers le bas.
• Parce qu'il shows'agit de quatre caractères, la sortie numérique doit être implémentée à la main.
  • dest une liste des chaînes de chiffres "1".."9".
  • nest une liste infinie de représentations numériques ["1","2","3",...]définies récursivement à l'aide de d.
• #convertit un Int xà sa forme ApplePie donné un premier argument supplémentaire qui est gcdde xà 15.

Haskell , 7 octets / ligne, 339 octets

L'exigence que les sauts de ligne soient significatifs en fait un défi non trivial à Haskell. Il n'y a presque aucun moyen d'insérer des sauts de ligne qui ne peuvent pas être supprimés, donc tout doit être fait avec des déclarations légitimement minuscules.

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

Essayez-le en ligne!

Gelée , 3 2 octets / ligne, 106 80 56 octets

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

Les lignes et les colonnes de la chaîne littérale sont transposées, donc la suppression des sauts de ligne gâche leur ordre.

Les lignes restantes sont des liaisons / fonctions distinctes et contiennent des appels de fonction ( ¢), elles ne peuvent donc être concaténées que si les appels de fonction sont également éliminés.

Essayez-le en ligne!

TI-BASIC, 4 octets par ligne

Étant donné que le but est uniquement de minimiser la longueur de ligne maximale, certaines lignes sont plus longues qu'elles ne devraient l'être, mais la plus petite que j'ai pu faire la plus longue était de 4 octets. Par conséquent, je pensais que cela rendrait le code plus facile à lire si je fusionnais les lignes qui pouvaient être combinées sans dépasser 4 octets.

"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

Non 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

À propos de la langue et des limitations

TI-BASIC est un langage à jetons et, dans ce cas, chacun des jetons fait 1 octet à l'exception des StrNvariables, qui sont 2 octets. En outre, vous pouvez laisser la plupart du temps les parenthèses fermantes. La remainder(fonction fait 2 octets, donc son utilisation nécessiterait au moins 5 octets (un pour la fonction, deux pour les arguments et un pour la virgule remainder(I,3). Au lieu de cela, j'ai utilisé les fonctions fPart(et not(pour le raccourcir, qui sont toutes deux des jetons de 1 octet. De plus, vous pouvez voir que j'ai Ansbeaucoup utilisé la variable intégrée , car toute expression qui est évaluée sur une ligne par elle-même y est automatiquement stockée. Je peux donc économiser quelques octets en fractionnant les expressions et les affectations.

Une autre stratégie était évidemment de minimiser les affectations de chaînes. Ma méthode pour ce faire dépendait de la longueur de ligne maximale dans le reste du code. Une fois que j'ai déterminé qu'il s'agissait de 4 octets, j'ai pu entasser autant de chaque chaîne sur la même ligne que possible pour minimiser la quantité d'affectations dont j'avais besoin. Je l'ai fait pour des raisons de lisibilité.

Les facteurs limitants dans ce code sont les affectations aux variables de chaîne et la concaténation avec les variables de chaîne. Les lignes Ans→Str1et les Str1+Ansdeux font au total 4 octets. Je devrais trouver un moyen d'éliminer complètement les variables de chaîne afin de minimiser davantage la longueur de ligne maximale dans mon code. Tout le reste peut être raccourci jusqu'à un maximum de 3 octets ou moins par ligne.

Le problème réside dans les affectations aux variables numériques, telles que 1→I. Vous ne pouvez pas jouer au golf plus loin sans trouver une solution sans variables qui ne dépasse pas 2 octets de longueur de ligne. Cela s'avère impossible pour ce défi.

Les opérateurs binaires comme +nécessitent le symbole de l'opérateur et les arguments gauche et droit. Donc, sans cela, vous ne seriez pas en mesure de concaténer des chaînes. Sans concaténation de chaînes, il n'y aurait aucun moyen d'afficher les chaînes nécessaires à ce programme pour terminer le défi sans dépasser 2 octets de longueur de ligne. Par conséquent, la limite théorique pour ce défi dans cette langue serait de 3 octets par ligne, ce que je n'ai pas pu atteindre.

C (gcc) , 2 octets par ligne, 374 368 320 310 262 octets

Je suppose qu'il peut être joué un peu plus au golf. Les barres obliques inverses qui échappent aux nouvelles lignes le rendent un peu 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\
)\
)\
;\
}

Essayez-le en ligne!

Python 3 , 4 octets / ligne, 113 octets

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)

Essayez-le en ligne!

PHP 7, 2 octets par ligne

(#
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 octet par ligne, 230 octets

Eh bien, ce n'était pas amusant à écrire. En tant que fongoïde, les structures de contrôle d'Aceto reposent fortement sur sa nature 2D, mais nous pouvons contourner cela avec beaucoup, beaucoup d'échappements conditionnels ( `). Le seul problème avec ceux-ci est qu'ils affectent la commande suivante, quelle que soit sa présence (tous les programmes Aceto sont des carrés, en interne), c'est pourquoi nous devons aligner le programme à certains endroits en insérant des lignes vides à certains points.

Les littéraux de chaîne ne peuvent pas vraiment être utilisés, mais les littéraux de caractères le peuvent (à certains endroits; encore une fois, nous devons les aligner).

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

Appelé avec 20, il imprime:

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

Tous les sauts de ligne doivent être significatifs. Les sauts de ligne qui peuvent être supprimés et les lignes adjacentes concaténées sans impact sur la sortie doivent être supprimés.

Ce n'est jamais le cas ici car cela va du bas vers le haut.

Il y a au moins un endroit où nous pouvons économiser 2 octets (en remplaçant le `Xpar un |ou #), mais je l'ai gardé tel quel en raison du coût d'exécution associé à l'exécution d'une courbe de Hilbert relativement grande.

J'ai également ignoré l'exigence implicite d'utiliser \rou de \r\nnouvelles lignes parce que je pense que c'est une erreur involontaire de l'OP. S'il y a une modification ou un commentaire renforçant cette exigence, je peux le changer sans trop de difficulté pour utiliser à la place les nouvelles lignes CR.

Le bytecount est basé sur l'encodage de codegolfing d'Aceto; Latin-7, dans lequel £est un seul octet.

Perl 5 , 2 octets par ligne, 182 octets

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

Essayez-le en ligne!

La syntaxe de Perl est très indulgente, donc de nombreuses lacunes peuvent être ajoutées au code et des commentaires ajoutés, ce qui rend l'idée de base assez simple. L'objectif principal de ce code est de construire une chaîne contenant le code que nous voulons exécuter, et evalce. En Perl, il est possible d'appeler une fonction à l'aide d'une chaîne ou d'une variable avec la &{...}notation, malheureusement, evaln'est pas appelable sous cette forme, mais l' evalbytesest, tant que vous l'appelez via l' CORE::espace de noms. La construction de cette chaîne était assez simple et le programme est passé directement à cet appel. Les chaînes sont construites en utilisant les sauts de ligne dans le cadre du XOR, pour les construire j'ai utilisé ce script. Pour garder cela valide, quelques endroits ont dû avoir des commentaires placés, de sorte que la suppression des sauts de ligne entraînerait un code non fonctionnel.

La routine FizzBuzz a été tirée de l'excellente réponse de primo .

Perl 5 , 1 octet par ligne, 172 octets

Donc, je sais (maintenant) que cela n'est pas valide , car un certain nombre de nouvelles lignes peuvent être supprimées, mais comme c'était mon approche initiale du problème, je l'ajoute. C'était amusant de voir jusqu'où vous pouvez pousser la syntaxe de Perl! J'ai apprécié ce problème à lui seul, même s'il n'est pas valide.

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

Essayez-le en ligne!

SmileBASIC, 9 sept octets par ligne, 159 155 154 152 octets

Ce fut un défi vraiment amusant. Malheureusement, la règle interdisant les sauts de ligne inutiles pose quelques problèmes (bien que heureusement, cela n'affecte pas la longueur de ligne maximale ici.) J'ai dû ajouter des commentaires entre les lignes comme A%=I/3et A=A%*3, car il A%=I/3A=A%*3est correctement analysé dans SB. J'ai pu utiliser une astuce pour omettre certains commentaires, car le remplacement Apar Erend cette ligne invalide (cela a quelque chose à voir avec les nombres écrits à l'aide de la Enotation, je pense. 3EEst considéré comme un nombre non valide plutôt qu'un nombre et un nom 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 plus grande limitation ici est d'obtenir des entrées. INPUT xest le moyen le plus simple autorisé, l'alternative étant de définir une fonction avec une valeur d'entrée comme DEF F xmais qui est toujours de 7 caractères. Faire une déclaration conditionnelle est également difficile; Je ne peux penser à rien de plus court que WHILE x.

JavaScript (ES6), 3 octets par ligne

Utilise la variable globale toppour accéder à l' windowobjet, à partir duquel nous avons evalle code suivant:

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

Vous devrez l'exécuter dans la console car il topest inaccessible à partir d'un extrait de pile en bac à sable.

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 octets par ligne, 248 242 230 octets

Puisque C # ne se soucie pas des sauts de ligne, il a besoin d'un commentaire en ligne à la fin de presque (merci Ørjan Johansen) chaque ligne pour se conformer aux règles. Ce programme attend n comme argument de ligne de commande. Voici avec autant de nouvelles lignes non supprimables que possible:

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

Mais comme la ligne la plus longue est de 9 octets, d'autres lignes peuvent également être aussi longues, réduisant ainsi certains octets:

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 octets / ligne, 93 octets

La norme max6 est déjà obsolète.

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

Essayez-le en ligne!

Python 2 et 3, 5 octets / ligne, 100 octets

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

Essayez-le en ligne!

JavaScript, max 6 octets / ligne, 528 octets

L'idée s'est arrachée d' ici .

Code arraché d' ici .

Merci à Anders Kaseorg pour g=evalavoir économisé un octet par ligne.

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)

Indépendant:

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

PHP, 4 octets / ligne

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

Essayez-le en ligne!

APL (Dyalog) , 5 octets par ligne

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

Essayez-le en ligne!

Rétine , 4 octets / ligne

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

Essayez-le en ligne!

R , 10 octets par ligne, 800 octets

La règle des «sauts de ligne significatifs» a rendu cela difficile. Actuellement, cela énonce simplement le code fizzbuzz dans une chaîne, puis l'exécute.

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)

Essayez-le en ligne!

Voici le code ApplePie concaténé (adapté du golf de MickyT ici ).

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

Et la version non golfée du code d'analyse:

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

Ici, j'utilise toStringpour concaténer la liste des symboles aen une seule chaîne. Cependant, le comportement par défaut consiste à séparer chaque symbole avec ,, nous appelons donc gsubà les remplacer par des valeurs nulles. Ensuite, nous le passons à parseeteval faisons le sale boulot.

Il est possible qu'il y ait une approche qui n'utilise pas cette méthode d'analyse de chaîne et tout droit jusqu'à FizzBuzz outils, mais il me semble que l' utilisation forou whileou définir un functionbesoin des lignes plus longues que l'approche actuelle.

Ruby, 10 5 octets / ligne, 354 214 octets

-140 octets du score brut 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}"

Comment ça marche

Ruby concatène automatiquement les séquences de littéraux de chaîne (à l'exception des littéraux à caractère unique tels que ?a) dans la même instruction. Cela signifie que cela x = "a" 'b' "c" %q{d}équivaut à x = "abcd". Nous l'utilisons pour diviser le code de type FizzBuzz en des chaînes beaucoup plus petites pour appeler eval, car +cela invalidera le programme en raison de la règle de suppression de nouvelles lignes, mais \cela entraînera des erreurs de syntaxe si les nouvelles lignes sont supprimées!

Julia 0,6 , 5 octets par ligne, 168 octets au 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)

Essayez-le en ligne!

Le printramène inévitablement (afaict) dans le territoire de 5 octets par ligne.

Non 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

*est l'opérateur de concaténation de chaînes, il a*p*"\n"forme donc "ApplePie \ n". |>est l'opérateur de chaînage de fonction (/ piping), donc la chaîne choisie est envoyée comme argument à print. Le sinn'est pas utilisé, il est juste là car il printdoit être dans un tableau pour avoir un espace important après (en utilisant l' #astuce après cela, le nombre d'octets max par ligne sera de 6).

Si le simple retour de la sortie sous forme de tableau est autorisé, cela peut être fait avec 4 octets max par ligne:

Julia 0,6 , 4 octets par ligne, 152 octets au 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#
)

Essayez-le en ligne!

Une fonction qui prend n et renvoie un tableau contenant la sortie attendue. La longueur de ligne maximale ici est limitée par n->- Julia a besoin de cela sur une seule ligne pour l'analyser correctement comme le début d'un lambda.

Pascal (FPC) -Sew , 6 octets par ligne, 348 320 octets

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.

Essayez-le en ligne!

Utilise FPC pour obtenir 6 octets par ligne; sans cela, le résultat serait bien pire. Il s'agit de la plus petite largeur de ligne possible car après writedoit être soit ;ou ((ou des espaces inutiles), donc un commentaire spécial est inséré pour éviter cela. Les caractéristiques de FPC qui ont influencé cette réponse sont:

1. // - démarrage de commentaires sur une ligne.
2. Les commentaires de bloc sous forme {$<something>...}sont des directives de compilation. Si la directive n'existe pas, FPC émettra un avertissement (et {$ ...}ainsi de suite). Dans ce programme, {et $sont séparés par une nouvelle ligne qui émettra l'avertissement lors de la suppression.
3. -Sew- Le compilateur s'arrête également après les avertissements afin que {et $rejoint l'arrêt de la compilation.

Japt , 3 octets par ligne

Presque réussi à le réduire à deux octets par ligne, mais le retour de la carte est interrompu s'il est suivi d'une nouvelle ligne.
L'implémentation FizzBuzz elle-même est issue du thread canonique FizzBuzz .

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

Essayez-le en ligne!

LOLCODE , 18 8 octets par ligne, 303 octets au 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

Essayez-le en ligne!

-10 octets par ligne en utilisant le caractère de continuation de ligne …, grâce à Ørjan Johansen!

Python 2 , 5 octets / ligne

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

Essayez-le en ligne!

JavaScript (ECMAScript6), 2 octets par ligne

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

Longue explication

La façon dont nous pouvons raccourcir les lignes consiste à transformer le code en chaîne et à échapper les extrémités de ligne, cela imposera une limite de 2 octets par ligne.

Devient alert(1)ainsi

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

Mais maintenant, votre code est une chaîne, nous devons donc exécuter la chaîne en tant que code. Je connais au moins 4 façons d'exécuter la chaîne comme code:

1. eval (code) . Ce qui prend au moins 5 octets pour appelereval(
2. setTimeout (code, timeout) . Exécute la fonction de manière asynchrone, mais éventuellement si vous passez une chaîne, elle invoquera eval en interne.
3. Vous pouvez profiter du DOM et mettre votre code dans un onclick=""attribut, mais je n'ai pas réussi à rendre la partie de création d'élément courte.
4. Appel du nouveau constructeur Function Function Function () analysera votre code dans une fonction anonyme que vous pourrez appeler plus tard (j'ai utilisé ceci).

Toutes les fonctions natives vivent à l'intérieur de l' objet fenêtre et en javascript, vous pouvez accéder aux propriétés de l'objet en utilisant la notation par points ainsi eval()devient window.eval(), ou vous pouvez accéder aux propriétés en utilisant la notation de parenthèse window['eval']() . Vous pouvez en profiter pour briser evalplusieurs lignes en utilisant la méthode décrite précédemment. Mais vous devez toujours taper la fenêtre , une astuce est que si vous n'êtes pas à l'intérieur d'un cadre, la variable supérieure est également window, donc window.eval devient top.eval (3 octets de moins).

w=top
w['eval']

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

Cela rendra le code minimum de 3 octets. Pour faire le code 2 octets, j'ai utilisé lenew Function(/*string*/); constructeur, mais j'ai dû être créatif pour y accéder sans avoir à le taper.

Tout d'abord, le constructeur Function vous permet de l'appeler comme une fonction en omettant le nouveau mot-clé, cela réduit 4 octets mais c'est également important pour une autre raison. Appelant le constructeur en fonction retourne encore une instance ce qui nous permet de tourner new Function(code)à Function(code). Une autre chose importante est que le constructeur Function a uncall méthode qui vous permet d'appeler n'importe quelle fonction mais en remplaçant la référence this, et le constructeur Function lui-même étant une fonction, vous pouvez appeler une méthode sur elle-même Function.call(null, code).

Toutes les fonctions natives sont des instances du constructeur Function, et tous les objets en javascript ont une propriété constructeur . Vous pouvez donc avoir accès au constructeur Function sur n'importe quelle fonction native comme alert.constructor, et en utilisant la méthode d' appel , nous pouvons exécuter le constructeur en tant que fonction. Maintenant, nous avons alert.constructor.call (null, code) renvoie une fonction.

en combinant les cinématiques précédentes, nous pouvons en faire alert['constructor']['call'](null, code)

Maintenant, nous avons juste besoin de trouver une fonction ou une méthode courte nommée, alors je choisis la méthode big () à l'intérieur du constructeur String. Je peux donc y accéder directement à partir d'une chaîne vide"".big

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

Ensuite, je viens de tout casser en 2 octets

Court er explication (TLDR)

J'accède au nouveau constructeur Function (code) pour analyser la chaîne au lieu de eval (code) . Ce constructeur est disponible à chaque fonction native en faisant anyFunction. constructeur , comme alert.constructor===Function. J'utilise une fonction / méthode à l'intérieur du String.prototype.big String.prototype.big.constructor.call(null, /*string*/) Mais y accéder directement à partir d'un littéral de chaîne "".biget le transformer en notation de parenthèse . ""['big']['constructor']['call'](0, CODE)pour pouvoir le casser en utilisant le \.

Pip , 3 octets par ligne, 72 octets au total

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

Essayez-le en ligne!

Pip est extrêmement flexible sur les espaces blancs, donc la seule stratégie qui semble faisable est de créer une chaîne, de la modifier de manière à ce que les sauts de ligne ne soient pas perturbés et de l'évaluer.

Nous créons une chaîne où chaque autre caractère est une nouvelle ligne, et prenons tous les autres caractères en utilisant UW(dérouler) et unaire @(obtenir le premier élément):

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

Le résultat @UWdevrait être notre code ApplePie, adapté de la solution FizzBuzz ici . Si des sauts de ligne dans la chaîne sont supprimés, cela n'entraînera pas le code complet, donnant une erreur de syntaxe ou une sortie incorrecte.

Il y a encore deux sauts de ligne en dehors de la chaîne. Nous les avons rendus obligatoires en utilisant l' Yopérateur (yank) - qui agit ici comme un no-op - ainsi que la façon dont Pip analyse les exécutions de lettres majuscules:

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

Donc, si ces nouvelles lignes sont supprimées, le programme analyse différemment et ne fait pas ce qu'il est censé faire.

Java 8, 7 octets par ligne, 171 octets

Un lambda vide prenant un int. Je soupçonne que cela obéit à l'exigence concernant les nouvelles lignes, mais je ne peux pas le prouver, et la vérifier par force brute prendrait environ un mois sur mon ordinateur. Alors ça 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");}

Essayez-le en ligne

Assez ennuyeux à cause des commentaires de la ligne. La seule chose intéressante ici est l'utilisation d'une Systemréférence nulle , qui semble nécessaire pour imprimer en standard sur moins de 8 octets par ligne. Notez également que l' printappel de méthode est le goulot d'étranglement.

Non golfé sans commentaires:

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