Нещодавно хтось запропонував більш жорсткі обмеження для довжини рядка Python за замовчуванням:

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

Але 80 символів занадто високі? Деякі пропонують 79 або навіть низькі 75, щоб дозволити терміналу, що має широкий 80 символів, підходити до коду з кількома стовпцями, присвяченими номерам рядків. Зрозуміло, що в кінцевому підсумку краще нижчі, оскільки нижчі межі дозволяють використовувати код у більшості ситуацій без переформатування.

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

Ваша мета - знайти та продемонструвати мінімальну довжину рядка, яку вимагає ваша улюблена мова, написавши варіант FizzBuzz з найменшою кількістю символів у будь-якому рядку.

Вхідні дані

Ціле число, n , будь-яким потрібним методом.

Вихід

Роздрукуйте числа від 1 до n , ( n ≥ 1, n ∈ ℤ), розділених перервами рядків, за винятком:

• для кратних 3-х друкованих "Apple"
• для кратних по 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і повертає a 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"відповідність шаблону використовується для помилки, якщо рядок має більше одного символу.
• Третій трюк - оператори &та %оператори, які дозволяють змусити рядок закінчуватися символом оператора для першого фокусу. Нам це потрібно для завершення рядкових літералів, оскільки \"вони занадто широкі для додавання --.
  • &є загальним, визначеним таким, що 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

Безумовно

"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 байти в довжині рядка. Це, здається, неможливо для цього виклику.

Бінарні оператори, як-от, +вимагають символ оператора та аргументи зліва та справа. Тож без цього ви б не змогли з'єднати рядки. Без конкатенації рядків не було б можливості відобразити рядки, необхідні для цієї програми для завершення завдання, не перевищуючи 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#
)#
)#
(#
)#
;#

Ацето , 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.

Байт-рахунок базується на кодуванні кодового гольфу Aceto; Латинська-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 байти

Отже, я (зараз) знаю, що це недійсно , тому що купу нових рядків можна видалити, але оскільки це був мій оригінальний підхід до проблеми, я додаю її. Було весело побачити, як далеко ви можете підштовхнути синтаксис Перла! Мені подобається ця проблема з власної заслуги, навіть якщо вона недійсна.

&
{
(
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 # не піклується про переривання рядків, йому потрібен коментар в одній лінійці наприкінці майже (спасибі Ørjan Johansen) кожного рядка, щоб відповідати правилам. Ця програма очікує 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)

Нерозроблений:

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неминуче вводить це (факсимічне значення) в 5 байт на лінію лінії.

Безголівки:

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". |>є оператором ланцюга функцій (/ трубопроводів), тому вибрана рядок надсилається як аргумент 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- Компілятор також зупиняється після того, як попередження , так що {і $приєдналися зупинка компіляції.

Япт , 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 байт на рядок, використовуючи символ продовження рядка …, завдяки Ørjan Johansen!

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

Але тепер ваш код є рядком, тому нам потрібно виконати рядок як код. Я знаю щонайменше чотири способи виконання рядка як коду:

1. eval (код) . Що займає щонайменше 5 байт для дзвінкаeval(
2. setTimeout (код, час очікування) . Роботи функціонують асинхронно, але необов'язково, якщо ви передасте рядок, вона викликатиме eval внутрішньо.
3. Ви можете скористатися DOM і ввести свій код всередині onclick="" атрибута, але мені не вдалося зробити частину створення елемента короткою.
4. Викликання конструктора функцій нової функції () розбере ваш код на анонімну функцію, яку ви можете зателефонувати пізніше (я використав це).

Всі рідні функція живе всередині вікна об'єкта і в 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*/); конструктор, але мені довелося бути творчим, щоб отримати доступ до нього, не вводивши його.

По-перше, конструктор функцій дозволяє викликати його як функцію, що опускає нове ключове слово, це зменшує 4 байти, але це також важливо з іншої причини. Виклик конструктора як функція все ще повертає екземпляр цього дозволяє нам звернутися new Function(code)до Function(code). Ще одна важлива річ у тому, що конструктор функцій має acall метод, який дозволяє викликати будь-яку функцію, але переосмисливши цю посилання, а сам конструктор функцій є функцією, яку ви можете назвати методом на ній самостійно Function.call(null, code).

Усі нативні функції - це екземпляри конструктора функцій, а всі об'єкти в JavaScript мають властивість конструктора . Таким чином, ви можете мати доступ до конструктора функцій на будь-якій нативної функції, як alert.constructor, і за допомогою методу виклику ми можемо виконати конструктор як функцію. Тепер у нас aler.constructor.call (null, code) повертає функцію.

комбінуючи попередні архітектури, ми можемо перетворити його alert['constructor']['call'](null, code)

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

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

Тоді я просто розбив кожну річ у 2 байти

Короткий пояснення ер (TLDR)

Я звертаюся до нового конструктора функцій (коду), щоб проаналізувати рядок замість eval (код) . Цей конструктор доступний у кожній нативної функції, виконуючи будь-якуфункцію. конструктор , як 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"

Спробуйте в Інтернеті!

Піп надзвичайно гнучкий щодо простору пробілів, тому єдиною стратегією, яка здається здійсненною, є створення рядка, модифікація його таким чином, щоб не потрібно було порушувати нові рядки та не зводити їх.

Ми створюємо рядок, де кожен інший символ є новим рядком, і беремо будь-який інший його символ, використовуючи UW(unweave) та unry @(get first element):

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

Результатом @UWповинен бути наш ApplePie-код, адаптований з рішення FizzBuzz тут . Якщо будь-які нові рядки в рядку буде видалено, це не призведе до повного коду, даючи або синтаксичну помилку, або неправильний вихід.

За межами рядка є ще два нових рядки. Ми зробили це обов'язковим за допомогою Yоператора (yank), який тут виступає як неоперативний, разом із тим, як 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виклик методу є вузьким місцем.

Ungolfed без коментарів:

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