최근 누군가 파이썬의 기본 줄 길이에 대해 더 엄격한 제한을 제안했습니다.

분명히 어떤 프로그램도 전체적인 이유로 여러 줄에 80 자 이상을 사용해서는 안됩니다. 가독성과 유지 관리 성을 위해 무엇보다도 텍스트 표준의 너비를 적절히 조정할 수 있도록 확실한 표준을 갖추는 것이 중요합니다. 부수적 인 이점으로, 회의에서 검토 용 인쇄 페이지 또는 펀치 카드와 같이 제한이있을 수 있고 줄 바꿈을 추가 할 수없는 매체로 코드를 쉽게 전송할 수 있습니다.

그러나 80자가 너무 큽니까? 일부는 80 자 너비의 터미널이 행 번호 전용의 몇 개의 열로 코드에 맞도록 79 또는 75까지 줄인다고 제안합니다. 한계가 낮을수록 코드를 다시 포맷하지 않고 더 많은 상황에서 사용할 수 있으므로 분명히 궁극적으로 낮을수록 좋습니다.

max6 표준 소개

목표는 모든 줄에서 문자 수가 가장 적은 FizzBuzz 변형을 작성하여 좋아하는 언어에 필요한 최소 줄 길이를 찾아 보여주는 것입니다.

입력

원하는 방법을 통한 정수 n 입니다.

산출

다음을 제외하고 줄 바꿈으로 구분하여 1부터 n 까지의 숫자 ( n ≥ 1, n ∈ ℤ)를 인쇄합니다 .

• 3 장의 배수 "Apple"
• 5 프린트의 배수의 경우 "Pie"
• 3 및 5 인쇄의 배수 "ApplePie"

채점

줄 바꿈 (Cr, CrLf, Lf 또는 기타 시스템 표준 나누기, 원하는대로 지정)을 포함하지 않는 최대 줄 길이 (바이트) 및 타이 브레이커로서 전체 코드 길이 (바이트)입니다.

규칙

모든 줄 바꿈은 의미가 있어야합니다. 출력에 영향을주지 않고 제거 할 수 있고 인접한 줄을 직접 연결 한 줄 바꿈을 제거 해야 합니다.

> <> 행당 1 바이트, 243 (161) 135 바이트

Jo King 덕분에 -26 바이트!

2D 언어 FTW! 2D 구조 대신 goto 명령어를 사용하여 루프와 분기를 작성하는 것은 재미 있지 않습니다.

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 바이트 / 라인, 494471470 463 453450 461 바이트

편집하다:

• -26 bytes : 여분의 줄 바꿈 및 관련 주석 표식을 제거하고로 변경 -1+x했습니다 x-1.
• +3 바이트 : 죄송합니다 . --뒤에 추가 줄이 필요했습니다 x-.
• 바이트 -1 :에서 f사용 c 47:[]하는 대신 [c 47&0].
• -7 바이트 : 개행 처리를로 이동하십시오 w.
• -10 바이트 : 인라인 a="Apple"및 인 ( p="Pie"in) #및 15 경우에 더미 재귀를 사용합니다.
• -3 바이트 : 인라인 w에f . 와 --사이의 중복 을 제거합니다 .x15
• +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의보다 드물게 사용되는 들여 쓰기 무감각 모드로 작성됩니다 {}. 실제로 전체 프로그램이 아닌 함수를 정의하고 있기 때문에 바이트 수를 계산하는 방법을 잘 모르겠습니다. 나는 방어 계산 선택한 모두{} 들과 추가를; 선언 세퍼레이터 (후자는 일반적으로 정상 하스켈 모드 개행되는).
• --줄 바꿈을 "의미있는"것으로 만드는 주요 요령은 줄 주석으로, 다음 줄 바꿈을 제거 할 수 없게 만들고 이전 줄이 연산자 문자로 끝나는 경우 이전 줄 바꿈 (줄 주석의 일부가 아님) .
• 두 번째 요령은 "문자열 간격"입니다. \ 문자열 리터럴에서 백 슬래시 입니다. 구분 기호가있는 문자열 간격이 구문 분석 된 문자열에서 제거됩니다.
  • 문자열 간격의 줄 바꿈이 제거되면 문자열에 백 슬래시가 추가됩니다. for "Apple"및 "Pie"이것은 출력에 직접 나타납니다. 문자열에 둘 이상의 문자가있는 경우 For "8"및 "9"패턴 일치를 사용하여 오류가 발생합니다.
• 세 번째 트릭은 &and %연산자로, 첫 번째 트릭의 연산자 문자로 줄을 강제 종료합니다. 문자열 리터럴을 끝내려면 이것이 필요합니다.\"덧붙이기에는 너무 넓기-- .
  • & 다음과 같이 정의 된 일반적인 것입니다. x&y=x .
  • %는 문자열 인수의 길이가 1이어야하도록 [a]%y=a대체 !!0하고 동시에 시행 할 수 있도록 정의됩니다 .
• 개행 문자는 다음과 같이 특별한 문제를 제기합니다. \n 행에 3 바이트 만있는 문자열 리터럴에 맞지 않는 것처럼 보이기 때문에 가 있습니다.
  • 따라서 숫자에서 아래쪽으로 세어 더 쉽게 정의 된 문자를 문자에서 문자 c x=["9"%0,"8"%0..]!!x로 변환하는 데 사용됩니다 .Int'9'
• 때문에 show네 자, 숫자 출력은 손으로 구현해야합니다.
  • d숫자 문자열 목록입니다 "1".."9".
  • n를 ["1","2","3",...]사용하여 재귀 적으로 정의 된 무한한 숫자 표현 목록입니다 d.
• #변환하여 Int x그 ApplePie 폼은이다 엑스트라 첫번째 인수 소정 gcd의 x15한다.

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은 토큰 화 된 언어이며,이 경우 각 토큰은 StrN변수를 제외한 1 바이트 ( 2 바이트)입니다. 또한 대부분 괄호를 닫지 않아도됩니다. remainder(함수 그래서 (인수하는 기능 하나, 둘, 및 콤마의 하나를 적어도 5 바이트를 필요로하여, 2 바이트이다 remainder(I,3). 대신 fPart(and 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\
)\
)\
;\
}

온라인으로 사용해보십시오!

파이썬 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 프로그램은 내부적으로 정사각형입니다). 따라서 특정 지점에 빈 줄을 삽입하여 프로그램을 특정 위치에 정렬해야합니다.

문자열 리터럴은 실제로 사용할 수 없지만 char 리터럴은 사용할 수 있습니다 (일부에서는 정렬해야 함).

&
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로모그래퍼 |또는# ),하지만이 때문에 상대적으로 큰 힐버트 곡선을 통해 실행과 관련된 런타임 비용이 그대로 나는 그것을 유지.

또한 OP에 의해 의도하지 않은 실수라고 생각하기 때문에 사용 \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 루틴은 primo의 탁월한 답변 에서 가져 왔습니다 .

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
)

온라인으로 사용해보십시오!

스마일, 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 바이트, 248242230 바이트

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

파이썬 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)

온라인으로 사용해보십시오!

자바 스크립트, 최대 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 (Dyalog) , 라인 당 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⍝
}¨⍳⎕
∇

온라인으로 사용해보십시오!

Retina , 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.
$.&

온라인으로 사용해보십시오!

아르 자형 , 라인 당 10 바이트, 800 바이트

"의미있는 줄 바꿈"규칙은이를 어렵게 만들었습니다. 현재 이것은 피즈 버즈 코드를 문자열로 철자 한 다음 실행합니다.

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 's golf here ).

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

그리고 구문 분석 코드의 ungolfed 버전 :

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

여기서는 toString기호 목록을 a단일 문자열로 연결하는 데 사용 합니다. 그러나 기본 동작은 각 기호를로 분리하는 ,것이므로 기호 gsub를 null로 바꾸도록 호출 합니다. 그런 다음에 전달합니다parse 하고eval 더러운 작업을 수행 할 수 있습니다.

그것은 fizzbuzz이 문자열 구문 분석 방법과 단지 바로 구현까지를 사용하지 않는 방법이 있다고 가능하지만, 사용하는 나에게 보인다 for거나 while또는 정의 function의 요구에 현재 방식보다 긴 줄을.

루비, 10 5 바이트 / 라인, 354214 바이트

@NieDzejkob의 원시 점수에서 -140 바이트.

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

작동 원리

루비는 ?a같은 문장에서 문자열 리터럴 시퀀스 (와 같은 단일 문자 리터럴 제외)를 자동으로 연결 합니다. 즉, 이는 x = "a" 'b' "c" %q{d}에 해당합니다 x = "abcd". 우리는 호출을 위해 더 작은 문자열로 코드처럼 FizzBuzz - 더를 분할하려면이 옵션을 사용 eval하기 때문에,와 +프로그램을 무효화 의한 통치 제거-줄 바꿈에 있지만은 \개행 밖으로 촬영하는 경우 구문 오류가 발생합니다!

Julia 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 바이트로이 불가피하게 (AFAICT)를 제공합니다.

언 골프 드 :

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 바이트로 수행 할 수 있습니다.

Julia 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->. Julia는 람다의 시작 부분으로 올바르게 구문 분석하기 위해 단일 줄로 요구합니다.

파스칼 (FPC) -Sew , 라인 당 6 바이트, 348320 바이트

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 바이트

줄당 2 바이트로 줄이려고했지만 줄 바꿈이 있으면 맵에서 리턴이 중단됩니다.
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

온라인으로 사용해보십시오!

…Ørjan Johansen 덕분에 줄 연속 문자를 사용하여 줄당 -10 바이트 !

파이썬 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 (code) . 호출하는 데 5 바이트 이상 필요eval(
2. setTimeout (코드, 타임 아웃) . 함수를 비동기 적으로 실행하지만 선택적으로 문자열을 전달하면 내부적으로 eval을 호출합니다.
3. DOM을 활용하여 코드를 onclick="" 속성 는 있지만 요소 생성 부분을 짧게 만들 수는 없었습니다.
4. 함수 생성자를 호출하면 new Function () 은 나중에 호출 할 수있는 익명 함수로 코드를 구문 분석합니다 (이것을 사용했습니다).

내부의 모든 기본 기능의 삶 창 객체와 사용자가 사용하는 객체 속성에 액세스 할 수 있습니다 자바 스크립트에서 점 표기법은 이렇게 eval()하게 window.eval()하거나 사용하여 속성에 액세스 할 수 있습니다 브래킷 표기법을 window['eval']() . eval앞에서 설명한 방법을 사용하여 여러 줄 을 나누기 위해이를 활용할 수 있습니다 . 하지만 여전히 창 을 입력해야합니다 . 한 가지 트릭은 프레임 안에 있지 않으면 top 변수도 window이므로 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). 또 다른 중요한 점은 Function 생성자가 함수 call를 호출하지만이 참조를 재정의 하는 메소드를 가지고 있으며 Function 생성자 자체는 자체적으로 메소드를 호출 할 수있는 함수라는 것입니다Function.call(null, code) 입니다.

모든 기본 함수는 함수 생성자의 인스턴스이며, 자바 스크립트의 모든 객체에는 생성자 속성이 있습니다. 따라서와 같은 기본 함수 alert.constructor에서 호출을 사용하여 함수 생성자를 액세스 할 수 있습니다 메소드를 하여 생성자를 함수로 실행할 수 있습니다. 이제 alert.constructor.call (null, code) 함수를 반환합니다.

이전의 테크닉을 결합하여 alert['constructor']['call'](null, code)

이제 짧은 이름의 함수 또는 메소드를 찾아야하므로 String 생성자 에서 big () 메소드를 선택합니다 . 빈 문자열에서 직접 액세스 할 수 있습니다."".big

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

그런 다음 방금 2 바이트로 모든 것을 끊었습니다.

짧은 어 설명 (TLDR)

eval (code) 대신 문자열을 구문 분석 하기 위해 새로운 Function (code) 생성자에 액세스하고 있습니다. 이 생성자는 anyFunction을 수행하여 모든 기본 함수에서 사용할 수 있습니다. 같은 생성자 . String.prototype.big 내부에서 함수 / 메서드를 사용하고 있지만 문자열 리터럴에서 직접 액세스 하여 대괄호 표기법으로 설정했습니다 . 를 사용하여 중단 할 수 있습니다 .alert.constructor===Function String.prototype.big.constructor.call(null, /*string*/)"".big""['big']['constructor']['call'](0, CODE)\

Pip , 라인 당 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) 및 단항 @(첫 번째 요소 가져 오기 )을 사용하여 다른 모든 문자를 가져옵니다.

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

그 결과 @UW는 FizzBuzz 솔루션 에서 수정 한 ApplePie 코드 여야합니다 . 문자열의 개행 문자가 삭제되면 전체 코드가 생성되지 않아 구문 오류가 발생하거나 출력이 잘못됩니다.

문자열 외부에는 여전히 두 개의 줄 바꿈이 있습니다. YPip이 대문자를 구문 분석하는 방식과 함께 (여기서는 작동하지 않는) 연산자 를 사용하여 이러한 필수 사항을 작성했습니다 .

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