Недавно кто-то предложил более строгие ограничения для длины строки Python по умолчанию:

Очевидно, что ни одна программа не должна использовать более 80 символов в строке по целому ряду причин. Прежде всего, для удобочитаемости и удобства обслуживания важно иметь твердый стандарт, чтобы мы могли соответствующим образом отрегулировать ширину наших текстовых редакторов. В качестве вторичного преимущества код может быть легко перенесен на носитель, который может иметь ограничения, и когда добавление разрывов строк может отвлекать, например, печать страниц для просмотра на собрании или перфокарты.

Но 80 символов слишком высоко? Некоторые предлагают 79, или даже всего 75, чтобы позволить терминалу шириной 80 символов соответствовать коду с несколькими столбцами, посвященными номерам строк. Понятно, что в конечном итоге чем меньше, тем лучше, поскольку нижние пределы позволяют использовать код в большем количестве ситуаций без переформатирования.

Представляем стандарт max6

Ваша цель - найти и продемонстрировать минимальную длину строки, требуемую вашим любимым языком, написав вариант FizzBuzz с наименьшим количеством символов в любой строке.

вход

Целое число n через любой желаемый метод.

Выход

Выведите числа от 1 до n , ( n ≥ 1, n ∈ ℤ), разделенных переносами строк, кроме:

• для кратного 3-х отпечатка "Яблоко"
• для кратных 5 оттисков "Пирог"
• для кратных как 3, так и 5 отпечаток "ApplePie"

счет

Максимальную длину строки в байтах, не включая разрыв строки (Cr, CrLf, Lf или другой системный стандартный разрыв, задайте по желанию) и общую длину кода в байтах в качестве прерывателя связей.

правила

Все разрывы строк должны быть значимыми. Разрывы строк, которые могут быть удалены, и смежные строки, непосредственно соединенные без влияния на вывод, должны быть удалены.

> <> , 1 байт на строку, 243 161 135 байтов

-26 байтов благодаря Джо Кингу!

2D языки FTW! Хотя написание циклов и ветвей с использованием goto-инструкций вместо 2D-структуры не очень весело.

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

Попробуйте онлайн! Или посмотрите на рыбную площадку !

Рыба плывет вниз по коду, используя условные переходы, чтобы пропустить вещи в зависимости от того, что разделяет аккумулятор.

Я считаю, что это соответствует спецификации: все новые строки удаляются, рыба всегда попадает в начальную v(единственная существующая инструкция по изменению направления), поэтому рыба всегда плывет вниз в первом столбце. Таким образом, удаление новой строки приводит к простому удалению следующего символа с пути рыбы, и я не думаю, что вы можете удалить любой из символов без изменения вывода.

Haskell , 3 байта / строка, 494 471 470 463 453 450 461 байт

РЕДАКТИРОВАТЬ:

• -26 байт: удалены некоторые избыточные разрывы строк и связанные с ними маркеры комментариев, и изменено -1+x на x-1.
• +3 байта: упс, нужна дополнительная --строка послеx- .
• -1 байт: fиспользуется c 47:[]вместо[c 47&0] .
• -7 байт: переместить обработку новой строки в w .
• -10 байт: встроенные a="Apple"и p="Pie"в# и использовать фиктивную рекурсию для 15 случая.
• -3 байта: встроенный wв f. Удалить лишние --между xи15 .
• +11 байт: Опять снова! В моей теории разрыва струн была дыра. Исправлено введением %функции. Наконец-то сделали несколько автоматических тестов, чтобы убедиться, что больше никаких сюрпризов.

fпринимает Intи возвращает 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}

Попробуйте онлайн!

Ограничения источника теста!(Строка 70 исключена из тестирования, потому что удаление ее новой строки вызывает бесконечный цикл без вывода.)

Версия с удаленными наиболее важными хитростями:

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

Как это работает

• Этот код написан в более редко используемом режиме нечувствительности к отступам в Haskell, который запускается, например, окружением всей программы {}. Поскольку я на самом деле определяю функцию, а не целую программу, я не совсем уверен, как считать байты; Я выбрал оборонительную рассчитывать как{} S и дополнительной ;декларации разделитель (последний , как правило , является символом новой строки в обычном режиме Haskell.)
• Основной трюк для того, чтобы сделать переводы строки значимыми, - это --комментарии к строкам, которые делают следующую строку не удаляемой, а также предыдущий символ новой строки в случае, когда предыдущая строка заканчивается символом оператора (который сам по себе не является частью комментария строки) ,
• Второй трюк - это «разрывы строк», последовательность пробелов между \ обратными слешами в строковых литералах, с отступом для продолжения строки с возможным отступом. Пробел с разделителями удаляется из проанализированной строки.
  • Если новая строка пробела удаляется, она становится дополнительной обратной косой чертой в строке. Ибо "Apple"и "Pie"это проявляется прямо в выводе. Для "8"и "9"сопоставление с образцом используется для выдачи ошибки, если строка содержит более одного символа.
• Третий прием - это операторы &and %, которые позволяют принудительно завершить строку символом оператора для первого приема. Нам нужно это закончить строковые литералы, потому что\" он слишком широк для добавления-- .
  • & является общим, определенным так, что x&y=x .
  • %определяется так, что [a]%y=a, позволяя ему заменить !!0и одновременно принудительно установить, что его строковый аргумент должен иметь длину 1.
• Символ новой строки ставит особую проблему, так как \n кажется невозможным поместиться в строковый литерал, содержащий только 3 байта в строке.
  • Следовательно, более легкое определение c x=["9"%0,"8"%0..]!!xиспользуется для преобразования из Intсимвола в символ, начиная с цифры '9'вниз.
• Поскольку showэто четыре символа, вывод числа должен осуществляться вручную.
  • dсписок из цепочек цифр "1".."9".
  • nявляется бесконечным списком числовых представлений, ["1","2","3",...]определенных рекурсивно с использованием d.
• # преобразует Int x его ApplePie форме дали дополнительный первый аргумент , который является gcdиз xс 15.

Haskell , 7 байт / строка, 339 байт

Требование, чтобы разрывы строк были значимыми, делает это нетривиальной задачей в Haskell. Практически нет способов вставить разрывы строк, которые нельзя удалить, поэтому все должно быть сделано с помощью крошечных операторов.

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

Попробуйте онлайн!

Желе , 3 2 байта / строка, 106 80 56 байтов

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

Строки и столбцы строкового литерала транспонируются, поэтому удаление новых строк портит их порядок.

Остальные строки являются отдельными ссылками / функциями и содержат вызовы функций (¢ ), поэтому их можно объединять, только если вызовы функций также исключены.

Попробуйте онлайн!

TI-BASIC, 4 байта на строку

Поскольку цель состоит только в том, чтобы минимизировать максимальную длину строки, некоторые строки длиннее, чем они должны быть, но самая маленькая строка, которую я мог сделать, была 4 байта. Поэтому я чувствовал, что это облегчит чтение кода, если я объединю строки, которые можно объединить, не превышая 4 байта.

"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

О языке и ограничениях

TI-BASIC - это токенизированный язык, и в этом случае каждый из токенов составляет 1 байт, за исключением StrNпеременных, которые составляют 2 байта. Кроме того, вы можете оставить закрывающие скобки большую часть времени. remainder(Функция 2 байта, так что использование этого потребуется , по меньшей мере 5 байт (один для функции, два для аргументов, и один для запятой в remainder(I,3). Вместо этого я использовал fPart(и not(функцию , чтобы сделать его короче, что оба 1 байты жетонов. Кроме того, вы можете видеть, что я использовал встроенную переменнуюAns довольно , поскольку любое выражение, которое оценивается в строке, автоматически сохраняется в ней. Итак, я могу сэкономить несколько байтов, разделив выражения и назначения.

Другая стратегия заключалась в том, чтобы минимизировать строковые назначения. Мой метод для этого зависел от максимальной длины строки в остальной части кода. Как только я определил, что это 4 байта, я смог собрать как можно больше каждой строки в одной строке, чтобы минимизировать количество необходимых мне назначений. Я сделал это ради удобства чтения.

Ограничивающими факторами в этом коде являются присвоения строковым переменным и конкатенация со строковыми переменными. Линии Ans→Str1иStr1+Ans оба имеют длину 4 байта. Мне нужно было бы найти способ полностью исключить строковые переменные, чтобы дополнительно минимизировать максимальную длину строки в моем коде. Все остальное может быть сокращено до максимум 3 байтов или меньше на строку.

Проблема заключается в присвоении числовых переменных, таких как 1→I . Вы не можете играть дальше, не придумав решения без переменных, длина которых не превышает 2 байта. Это оказывается невозможным для этого вызова.

Двоичные операторы типа like +требуют символа оператора и левого и правого аргументов. Таким образом, без этого вы не сможете объединить строки. Без конкатенации строк не было бы возможности отобразить строки, необходимые для выполнения этой программы, без превышения длины строки в 2 байта. Поэтому теоретический предел для этой задачи на этом языке будет 3 байта на строку, чего я не смог достичь.

C (gcc) , 2 байта на строку, 374 368 320 310 262 байта

Я предполагаю, что это может быть игра в гольф немного больше. Обратная косая черта, экранирующая символы новой строки, делает это своего рода тривиальным.

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

Попробуйте онлайн!

Python 3 , 4 байта / строка, 113 байтов

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)

Попробуйте онлайн!

PHP 7, 2 байта на строку

(#
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 байт на строку, 230 байт

Ну, это было не весело писать. Как грибок, управляющие структуры Aceto в значительной степени зависят от его 2D-характера, но мы можем обойти это с помощью множества условных выходов (` ). Единственная проблема с ними заключается в том, что они влияют на следующую команду, независимо от ее присутствия (все программы Aceto являются квадратами, внутренне), поэтому нам нужно выровнять программу в некоторых местах, вставляя пустые строки в некоторых точках.

Строковые литералы на самом деле не могут использоваться, но могут использоваться литералы-символы (в некоторых местах; опять же, нам нужно их выравнивать).

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

Вызывается с 20 , это печатает:

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

Все разрывы строк должны быть значимыми. Разрывы строк, которые можно удалить, и смежные строки, объединенные без влияния на вывод, должны быть удалены.

Это никогда не имеет место здесь, потому что это бежит снизу вверх.

Там, по крайней мере , одно место , где мы можем сохранить 2 байта (путем замены `Xс| или# ), но я сохранил его как есть из-за затрат времени выполнения, связанных с прохождением относительно большой кривой Гильберта.

Я также проигнорировал неявное требование для использования \r или\r\n перевода строки, потому что я считаю, что это непреднамеренная ошибка со стороны ФП. Если есть редактирование или комментарий, подкрепляющий это требование, я могу изменить его без особых проблем, чтобы использовать вместо него новые строки CR.

Bytecount основан на кодинговой кодировке Aceto; Latin-7, в котором £есть один байт.

Perl 5 , 2 байта на строку, 182 байта

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

Попробуйте онлайн!

Синтаксис Perl очень простителен, поэтому в коде можно добавить много пробелов и добавить комментарии, что делает основную идею довольно простой. Основная цель этого кода - создать строку, содержащую код, который мы хотим запустить, и evalего. В Perl можно вызывать функцию, используя строку или переменную с &{...}нотацией, но, к сожалению, evalне вызывается в этой форме, но . Чтобы это действовало, в нескольких местах должны были быть размещены комментарии, чтобы удаление новых строк приводило к неработающему коду.evalbytes выполняется до тех пор, пока вы вызываете ее черезCORE:: пространство имен. Построение этой строки было довольно простым, и программа передается непосредственно этому вызову. Строки строятся с использованием символов новой строки как части XOR, чтобы построить их я использовал этот скрипт

Программа FizzBuzz была взята из превосходного ответа .

Perl 5 , 1 байт на строку, 172 байта

Итак, я (теперь) знаю, что это неверно , потому что кучу новых строк можно удалить, но так как это был мой оригинальный подход к проблеме, я добавляю ее. Было весело видеть, как далеко вы можете продвинуть синтаксис Perl! Мне понравилась эта проблема сама по себе, хотя она недействительна.

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

Попробуйте онлайн!

SmileBASIC, 9 7 байт на строку, 159 155 154 152 байта

Это было действительно забавное испытание. К сожалению, правило против ненужных разрывов строк вызывает несколько проблем (хотя, к счастью, оно не влияет на максимальную длину строки здесь.) Мне пришлось добавлять комментарии между строками, подобными A%=I/3и A=A%*3, так A%=I/3A=A%*3как правильно анализируется в SB. Я смог использовать трюк, чтобы пропустить некоторые комментарии, так как замена Aна Eделает эту строку недействительной ( Eя думаю, что она имеет отношение к числам, написанным с использованием нотации. 3EСчитается недопустимым числом, а не числом и именем переменной.)

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

Самое большое ограничение здесь - получение информации. INPUT xэто самый простой способ, альтернативный - определить функцию с входным значением, таким какDEF F x но это все еще 7 символов. Делать условные заявления также сложно; Я не могу думать ни о чем короче WHILE x.

JavaScript (ES6), 3 байта на строку

Использует глобальную переменную topдля доступа к windowобъекту, из которого мы evalследующий код:

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

Вам придется запустить его в консоли, поскольку topон недоступен из изолированного фрагмента стека.

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 байтов на строку, 248 242 230 байтов

Так как C # не заботится о переводе строк, он нуждается в комментариях в конце почти каждой строки (спасибо Орджану Йохансену), чтобы соответствовать правилам. Эта программа ожидает n в качестве аргумента командной строки. Вот как можно больше не удаляемых символов новой строки:

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

Но так как самая длинная строка составляет 9 байтов, другие строки тоже могут получить такую ​​длину, сбрасывая некоторые байты:

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 байт / строка, 93 байта

Стандарт max6 уже устарел.

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

Попробуйте онлайн!

Python 2 и 3, 5 байт / строка, 100 байт

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

Попробуйте онлайн!

JavaScript, максимум 6 байт / строка, 528 байт

Идея разорвана отсюда .

Код разорван отсюда .

Спасибо Anders Kaseorg за g=evalсохранение байта в строке.

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 байта / строка

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

Попробуйте онлайн!

APL (Дьялог) , 5 байт на строку

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

Попробуйте онлайн!

Сетчатка , 4 байта / строка

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

Попробуйте онлайн!

R , 10 байт на строку, 800 байт

Правило «значимых разрывов строк» ​​усложняло задачу. В настоящее время это просто записывает код fizzbuzz в строку, а затем выполняет его.

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)

Попробуйте онлайн!

Вот сцепляются ApplePie код (адаптировано из MickyT в гольф здесь ).

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

И версия без разбора кода разбора:

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

Здесь я использую, toStringчтобы объединить список символов aв одну строку. Однако поведение по умолчанию состоит в том, чтобы разделять каждый символ ,, поэтому мы вызываем его, gsubчтобы заменить его на нули. Затем мы передаем его parseиeval делаем грязную работу.

Вполне возможно , что есть такой подход , который не использует этот метод строки синтаксического анализа и просто прямо вверх орудия FizzBuzz, но мне кажется , что использование forили whileили , образующий functionтребуется больше строк , чем текущий подход.

Ruby, 10 5 байт / строка, 354 214 байт

-140 байт из необработанного результата @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}"

Как это работает

Ruby автоматически объединит последовательности строковых литералов (за исключением односимвольных литералов, таких как ?a) в одном выражении. Это означает, что x = "a" 'b' "c" %q{d}эквивалентно x = "abcd". Мы используем это, чтобы разделить код, похожий на FizzBuzz, на строки меньшего размера для вызова eval, так как это +приведет к аннулированию программы из-за правила удаления новых строк, но \вызовет синтаксические ошибки, если новые строки будут удалены!

Юлия 0,6 , 5 байт на строку, всего 168 байт

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)

Попробуйте онлайн!

printПриносит это неизбежно (AFAICT) в 5 байт на территории линии.

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

*является оператором конкатенации строк, поэтому a*p*"\n"формирует «ApplePie \ n». |>является оператором цепочки функций (/ piping), поэтому выбранная строка отправляется в качестве аргумента print. Он sinне используется, он просто существует, потому что printдолжен находиться в массиве, чтобы после него было много пробелов (используя #трюк после того, как максимальное количество байтов в строке до 6).

Если разрешено просто возвращать вывод в виде массива, это можно сделать с максимум 4 байтами на строку:

Юлия 0,6 , 4 байта на строку, всего 152 байта

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

Попробуйте онлайн!

Функция, которая принимает n и возвращает массив, содержащий ожидаемый результат. Максимальная длина строки здесь ограничена n->- Юлия нуждается в том, чтобы в одной строке она правильно анализировалась как начало лямбды.

Паскаль (FPC) -Sew , 6 байтов на строку, 348 320 байтов

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.

Попробуйте онлайн!

Использует FPC для получения 6 байтов на строку; без него результат был бы намного хуже. Это наименьшая возможная ширина линии, поскольку после writeдолжно быть либо ;или ((или ненужный пробел), поэтому для избежания этого вставляется специальный комментарий. Функции от FPC, которые повлияли на этот ответ:

1. // - начало однострочных комментариев.
2. Блочные комментарии в форме {$<something>...}являются директивами компилятора. Если директива не существует, FPC выдаст предупреждение (и{$ ...} в том числе). В этой программе {и $разделены новой строкой, которая выдаст предупреждение при удалении.
3. -Sew- Компилятор также останавливается после предупреждений, чтобы {и $присоединившиеся остановили компиляцию.

Japt , 3 байта на строку

Почти удалось сократить его до двух байтов на строку, но возврат с карты прерывается, если за ней следует новая строка.
Сама реализация FizzBuzz происходит из канонического потока FizzBuzz .

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

Попробуйте онлайн!

LOLCODE , 18 8 байтов на строку, всего 303 байта

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

Попробуйте онлайн!

-10 байт на строку с использованием символа продолжения строки …, благодаря Орджану Йохансену!

Python 2 , 5 байт / строка

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

Попробуйте онлайн!

JavaScript (ECMAScript6), 2 байта на строку

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

Длинное объяснение

То, как мы можем сделать строки короче, - это преобразование кода в строку и экранирование концов строки, это накладывает ограничение в 2 байта на строку.

Так alert(1)становится

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

Но теперь ваш код является строкой, поэтому нам нужно выполнить строку как код. Я знаю как минимум 4 способа, которыми вы можете выполнить строку как код:

1. Eval (код) . Что занимает не менее 5 байтов для вызоваeval(
2. setTimeout (код, время ожидания) . Запускает функцию асинхронно, но при желании, если вы передадите строку, она вызовет eval внутри.
3. Вы можете воспользоваться DOM и поместить свой код в onclick="" атрибут, но мне не удалось сделать короткую часть создания элемента короткой.
4. Вызывая конструктора Function new Function () проанализирует ваш код в анонимной функции, которую вы можете вызвать позже (я использовал это).

Все родные функция живет внутри окна объекта и в JavaScript вы можете получить доступ свойств объектов с помощью точечной нотации так eval()будет window.eval(), или вы можете получить доступ к свойствам с помощью квадратных скобок window['eval']() . Вы можете воспользоваться этим, чтобы разбить evalнесколько строк, используя метод, описанный ранее. Но вы все равно должны ввести окно , одна хитрость в том, что если вы не находитесь внутри рамки, верх переменная также является окном, поэтому window.eval становится top.eval (на 3 байта меньше).

w=top
w['eval']

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

Так что это сделает код минимум 3 байта. Чтобы сделать код 2 байта, я использовалnew Function(/*string*/); конструктор, но мне пришлось проявить творческий подход, чтобы получить к нему доступ без необходимости набирать его.

Во-первых, конструктор Function позволяет вам вызывать его как функцию, опуская ключевое слово new, это сокращает 4 байта, но это также важно по другой причине. Вызов конструктора как функции по-прежнему возвращает экземпляр, что позволяет намnew Function(code) к Function(code). Еще одна важная вещь - это то, что конструктор Function имеет callметод, который позволяет вам вызывать любую функцию, но переопределяет эту ссылку, а сам конструктор Function является функцией, которую вы можете вызывать для нее сам метод, напримерFunction.call(null, code) .

Все нативные функции являются экземплярами конструктора Function, а все объекты в javascript имеют свойство constructor . Таким образом, вы можете иметь доступ к конструктору функций для любой встроенной функции, например alert.constructor, используя вызов метод мы можем выполнить конструктор как функцию. Теперь у нас есть alert.constructor.call (null, code), возвращающий функцию.

объединяя предыдущие течиники, мы можем превратить их в alert['constructor']['call'](null, code)

Теперь нам просто нужно найти функцию или метод с коротким именем, поэтому я выбираю метод big () внутри конструктора String. Так что я могу получить к нему доступ напрямую из пустой строки"".big

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

Тогда я просто разбил каждую вещь в 2 байта

Короткий эр объяснение (TLDR)

Я получаю доступ к новому конструктору Function (code) для анализа строки вместо eval (code) . Этот конструктор доступен для любой встроенной функции, выполняя функцию anyFunction. конструктор , вроде alert.constructor===Function. Я использую функцию / метод внутри String.prototype.big, String.prototype.big.constructor.call(null, /*string*/) но обращаюсь к нему напрямую из строкового литерала "".bigи превращаю его в скобочную запись . ""['big']['constructor']['call'](0, CODE)чтобы иметь возможность сломать его с помощью \.

Пип , 3 байта на строку, всего 72 байта

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

Попробуйте онлайн!

Pip чрезвычайно гибок в отношении пробелов, поэтому единственная стратегия, которая кажется выполнимой, состоит в том, чтобы создать строку, изменить ее таким образом, чтобы не прерывать переносы строки, и выровнять ее.

Мы создаем строку, где каждый другой символ является новой строкой, и принимаем каждый другой символ, используя UW(unweave) и унарный@ (get first element):

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

Результатом @UWдолжен стать наш код ApplePie, адаптированный из решения FizzBuzz здесь . Если какие-либо символы новой строки в строке будут удалены, это не приведет к полному коду, что приведет к ошибке синтаксиса или неверному выводу.

Есть еще две строки за строкой. Мы сделали это обязательным, используя Yоператор (yank), который в данном случае действует как no-op, а также способ, которым Pip выполняет синтаксический анализ заглавных букв:

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

Поэтому, если эти переводы строк удаляются, программа анализирует по-другому и не делает то, что должна.

Java 8, 7 байт на строку, 171 байт

Пустая лямбда-ап int. Я подозреваю, что это соответствует требованию относительно новых строк, но я не могу доказать это, и проверка его грубой силой заняла бы около месяца на моем компьютере. Такие вот дела.

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

Попробуйте онлайн

Довольно скучно из-за комментариев. Единственная интересная вещь здесь - это использование нулевой Systemссылки, которая, по-видимому, необходима для печати в стандартном формате менее 8 байтов на строку. Также обратите внимание, что printвызов метода является узким местом.

Разгромленный без комментариев:

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