เมื่อเร็ว ๆ นี้มีคนเสนอข้อ จำกัด ที่เข้มงวดมากขึ้นสำหรับความยาวบรรทัดเริ่มต้นของ Python:

เห็นได้ชัดว่าไม่ควรใช้โปรแกรมเกิน 80 ตัวอักษรต่อบรรทัดด้วยเหตุผลทั้งหมด สิ่งแรกและสำคัญที่สุดสำหรับการอ่านและการบำรุงรักษาเป็นสิ่งสำคัญที่จะต้องมีมาตรฐานที่มั่นคงดังนั้นเราจึงสามารถปรับความกว้างของเครื่องมือแก้ไขข้อความของเราได้อย่างเหมาะสม ในฐานะที่เป็นประโยชน์รองรหัสสามารถถ่ายโอนไปยังสื่อที่อาจมีข้อ จำกัด และที่เพิ่มบรรทัดแบ่งสามารถเบี่ยงเบนความสนใจเช่นหน้าพิมพ์เพื่อตรวจสอบในการประชุมหรือบัตรเจาะ

แต่ 80 ตัวอักษรสูงเกินไปหรือไม่ บางคนแนะนำ 79 หรือต่ำที่สุดถึง 75 เพื่อให้เทอร์มินัลแบบกว้าง 80 ตัวอักษรพอดีกับโค้ดโดยมีคอลัมน์ไม่กี่คอลัมน์ที่ใช้กับหมายเลขบรรทัด ชัดเจนที่สุดคือต่ำกว่าดีกว่าเนื่องจากขีด จำกัด ล่างอนุญาตให้ใช้รหัสในสถานการณ์มากขึ้นโดยไม่ต้องฟอร์แมตใหม่

แนะนำมาตรฐาน max6

เป้าหมายของคุณคือการค้นหาและสาธิตความยาวบรรทัดต่ำสุดที่ภาษาที่คุณโปรดปรานโดยการเขียนตัวแปร FizzBuzz ด้วยจำนวนอักขระน้อยที่สุดในบรรทัดใด ๆ

อินพุต

จำนวนเต็มnด้วยวิธีที่ต้องการ

เอาท์พุต

พิมพ์ตัวเลขจาก 1 ถึงn , ( n ≥ 1, n ∈ℤ) คั่นด้วยตัวแบ่งบรรทัดยกเว้น:

• สำหรับการพิมพ์ 3 รายการ "Apple"
• สำหรับการพิมพ์ 5 ครั้งแบบทวีคูณ
• สำหรับการทวีคูณของทั้ง 3 และ 5 พิมพ์ "ApplePie"

เกณฑ์การให้คะแนน

ความยาวบรรทัดสูงสุดเป็นไบต์ไม่รวมตัวแบ่งบรรทัด (Cr, CrLf, Lf หรือตัวแบ่งมาตรฐานอื่น ๆ ของระบบระบุตามที่ต้องการ) และความยาวโค้ดทั้งหมดในหน่วยไบต์เป็น tiebreaker

กฎระเบียบ

การขึ้นบรรทัดใหม่ทั้งหมดจะต้องมีความหมาย แบ่งสายที่สามารถถอดออกและสายที่อยู่ติดกันตัดแบ่งโดยตรงโดยไม่ส่งผลกระทบต่อการส่งออกจะต้องถูกลบ

> <> 1 ไบต์ต่อบรรทัด243 161 135 ไบต์

-26 ไบต์ขอบคุณ Jo King!

FTW ภาษา 2 มิติ! แม้ว่าการเขียนลูปและกิ่งก้านโดยใช้คำแนะนำ 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

ลองออนไลน์! หรือดูมันที่สนามเด็กเล่นปลา !

ปลาแหวกว่ายตามรหัสโดยใช้ gotos แบบมีเงื่อนไขเพื่อข้ามสิ่งต่าง ๆ ขึ้นอยู่กับสิ่งที่แบ่งการสะสม

ฉันเชื่อว่าสิ่งนี้ตรงตามข้อกำหนด: ไม่ว่าจะมีการขึ้นบรรทัดใหม่ใดปลามักจะเริ่มต้นv(คำแนะนำที่เปลี่ยนแปลงทิศทางเดียวเท่านั้น) ดังนั้นปลาจะว่ายลงในคอลัมน์แรกเสมอ ดังนั้นการลบบรรทัดใหม่มีผลเพียงแค่ลบอักขระถัดไปออกจากเส้นทางของปลาและฉันไม่คิดว่าคุณสามารถลบอักขระใด ๆ ได้โดยไม่ต้องเปลี่ยนผลลัพธ์

Haskell , 3 ไบต์ / บรรทัด, 494 471 470 463 453 450 461 ไบต์

แก้ไข:

• -26 ไบต์: ถูกลบออก linebreaks ซ้ำซ้อนและเกี่ยวข้องเครื่องหมายแสดงความคิดเห็นของพวกเขาและการเปลี่ยนแปลงเข้าสู่-1+xx-1
• +3 ไบต์: อุ๊ปส์ต้องใช้--สายพิเศษหลังจากx-นั้น
• -1 ไบต์: ในfการใช้งานแทนc 47:[][c 47&0]
• -7 ไบต์: wย้ายขึ้นบรรทัดใหม่ที่จะจัดการ
• -10 ไบต์: อินไลน์a="Apple"และp="Pie"ใน#และใช้การสอบถามซ้ำสำหรับกรณี 15 รายการ
• -3 ไบต์: Inline ในw fลบซ้ำซ้อน--ระหว่างและx15
• +11 ไบต์: โอ๊ะโออีกครั้ง! ทฤษฎีช่องว่างสตริงของฉันมีรู แก้ไขโดยการแนะนำ%ฟังก์ชั่น ในที่สุดก็ทำการทดสอบอัตโนมัติเพื่อให้แน่ใจว่าไม่มีความประหลาดใจอีก

fใช้เวลาและผลตอบแทนIntString

{;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 {}เรียกเช่นโดยรอบโปรแกรมทั้งหมดที่มี เนื่องจากฉันกำหนดฟังก์ชันมากกว่าโปรแกรมทั้งหมดฉันไม่แน่ใจว่าจะนับจำนวนไบต์อย่างไร ฉันได้รับการแต่งตั้งให้ defensively นับทั้ง{}และพิเศษ;คั่นประกาศ (หลังมักจะเป็นบรรทัดใหม่ในโหมดปกติ Haskell.)
• เคล็ดลับหลักสำหรับการขึ้นบรรทัดใหม่ "ความหมาย" คือ--ความคิดเห็นของบรรทัดซึ่งทำให้การขึ้นบรรทัดใหม่ไม่สามารถถอดออกได้และยังขึ้นบรรทัดใหม่ก่อนหน้าในกรณีที่บรรทัดก่อนหน้านี้สิ้นสุดลงในอักขระตัวดำเนินการ (ซึ่งไม่ใช่ส่วนหนึ่งของความคิดเห็นบรรทัด) .
• เคล็ดลับที่สองคือ "string gaps" ซึ่งเป็นลำดับของช่องว่างระหว่าง\แบ็กสแลชในตัวอักษรสตริงที่เยื้องสำหรับการต่อเนื่องของบรรทัดที่มีการเยื้องเป็นไปได้ ช่องว่างสตริงที่มีตัวคั่นจะถูกลบออกจากสตริงที่แยกวิเคราะห์
  • หากบรรทัดใหม่ของช่องว่างสตริงถูกลบออกมันจะกลายเป็นแบ็กสแลชที่เพิ่มเข้ามาในสตริง สำหรับ"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

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 ไบต์ ที่เกิดขึ้นเป็นไปไม่ได้สำหรับความท้าทายนี้

ตัวดำเนินการไบนารีเช่น+ต้องการสัญลักษณ์ตัวดำเนินการและอาร์กิวเมนต์ซ้ายและขวา ดังนั้นหากไม่มีสิ่งนี้คุณจะไม่สามารถต่อสตริงเข้าด้วยกันได้ หากไม่มีการต่อสตริงจะไม่มีวิธีแสดงสตริงที่จำเป็นสำหรับโปรแกรมนี้เพื่อให้การทดสอบเสร็จสมบูรณ์โดยไม่เกิน 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 ขึ้นอยู่กับลักษณะ 2 มิติของมันอย่างหนัก แต่เราสามารถหลีกเลี่ยงสิ่งนั้นได้ด้วยการหลีกหนีตามเงื่อนไขจำนวนมาก ( `) ปัญหาเดียวที่เกิดขึ้นคือมันมีผลกับคำสั่งถัดไปโดยไม่คำนึงถึงการมีอยู่ของมัน (โปรแกรม 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ด้วย a |หรือ#) แต่ฉันเก็บไว้เนื่องจากเป็นค่าใช้จ่ายรันไทม์ที่เกี่ยวข้องกับการวิ่งผ่านเส้นโค้งฮิลแบร์ตที่ค่อนข้างใหญ่

ฉันยังเพิกเฉยต่อข้อกำหนดโดยนัยสำหรับการใช้\rหรือการขึ้น\r\nบรรทัดใหม่เพราะฉันคิดว่าเป็นความผิดพลาดที่ไม่ได้ตั้งใจจาก OP หากมีการแก้ไขหรือแสดงความคิดเห็นที่เสริมข้อกำหนดนี้ฉันสามารถเปลี่ยนได้โดยไม่ต้องยุ่งยากในการใช้บรรทัดใหม่ CR แทน

จำนวน bytecount นั้นมาจากการเข้ารหัส codegolfing ของ 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::namespace การสร้างสตริงนั้นค่อนข้างตรงไปตรงมาและโปรแกรมถูกส่งผ่านไปยังการโทรนี้โดยตรง สตริงถูกสร้างขึ้นโดยใช้บรรทัดใหม่เป็นส่วนหนึ่งของ 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 # ไม่สนใจเรื่อง linebreaks จึงจำเป็นต้องมีความคิดเห็นออนไลน์ในตอนท้ายของเกือบ (ขอบคุณØ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)

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

ลองออนไลน์!

เรติน่า 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's Golf ที่นี่ )

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เพื่อแทนที่ด้วย nulls จากนั้นเราก็ผ่านมันไป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ด้วยเนื่องจาก+จะทำให้โปรแกรมใช้ไม่ได้เนื่องจากกฎการลบบรรทัดใหม่ แต่\จะทำให้เกิดข้อผิดพลาดทางไวยากรณ์หากมีการขึ้นบรรทัดใหม่!

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นี้นำมาซึ่งหลีกเลี่ยงไม่ได้ (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" |>เป็นฟังก์ชั่นการผูกมัด (/ ท่อ) 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 ต้องการให้ในบรรทัดเดียวเพื่อแยกวิเคราะห์อย่างถูกต้องตั้งแต่เริ่มแลมบ์ดา

Pascal (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 จะออกคำเตือน (และเปิด{$ ...}เช่นกัน) ในโปรแกรมนี้{และ$ถูกคั่นด้วย newline ซึ่งจะออกคำเตือนเมื่อถูกลบ
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 ไบต์ต่อบรรทัดโดยใช้อักขระต่อเนื่องของบรรทัด…ขอบคุณØ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\
)"

แต่ตอนนี้รหัสของคุณเป็นสตริงดังนั้นเราต้องดำเนินการสตริงเป็นรหัส ฉันรู้ว่าอย่างน้อย 4 วิธีที่คุณสามารถรันสตริงเป็นรหัส:

1. EVAL (รหัส)(รหัส) ซึ่งใช้เวลาอย่างน้อย 5 ไบต์ในการโทรeval(
2. setTimeout (รหัสหมดเวลา) เรียกใช้ฟังก์ชั่นแบบอะซิงโครนัส แต่เป็นทางเลือกถ้าคุณผ่านสตริงมันจะเรียกใช้ eval ภายใน
3. คุณสามารถใช้ประโยชน์จาก DOM และใส่รหัสของคุณใน onclick=""แอตทริบิวต์ แต่ฉันไม่สามารถจัดการเพื่อทำให้องค์ประกอบการสร้างองค์ประกอบสั้น
4. กล่าวอ้างถึง สร้างฟังก์ชั่นใหม่ 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*/);สร้าง แต่ฉันต้องมีความคิดสร้างสรรค์ในการเข้าถึงโดยไม่ต้องพิมพ์

ครั้งแรกตัวสร้างฟังก์ชั่นช่วยให้คุณสามารถเรียกมันว่าเป็นฟังก์ชั่นที่ละเว้นคำหลักใหม่นี้ลด 4 ไบต์ แต่มันก็มีความสำคัญด้วยเหตุผลอื่น การเรียกนวกรรมิกในขณะที่ฟังก์ชั่นยังคงส่งคืนอินสแตนซ์นี้ช่วยให้เราหันnew Function(code)ไปFunction(code)การอีกสิ่งที่สำคัญคือตัวสร้างฟังก์ชั่นมีcallวิธีการที่ช่วยให้คุณสามารถเรียกใช้ฟังก์ชันใด ๆ Function.call(null, code)แต่เอาชนะอ้างอิงนี้และตัวสร้างฟังก์ชั่นของตัวเองเป็นฟังก์ชั่นที่คุณสามารถเรียกวิธีการที่มันเหมือนตัวเอง

ฟังก์ชันเนทีฟทั้งหมดเป็นอินสแตนซ์ของตัวสร้างฟังก์ชั่นและวัตถุทั้งหมดใน javascript มีคุณสมบัติคอนสตรัคเตอร์ ดังนั้นคุณสามารถเข้าถึงตัวสร้างฟังก์ชั่นในฟังก์ชั่นพื้นเมืองใด ๆ เช่นalert.constructorและใช้วิธีการโทรที่เราสามารถเรียกใช้ตัวสร้างเป็นฟังก์ชั่น ตอนนี้เรามี alert.constructor.call (null, code) ส่งคืนฟังก์ชัน

การรวมสิ่งที่ผ่านมาก่อนหน้านี้เราสามารถเปลี่ยนเป็น alert['constructor']['call'](null, code)

ตอนนี้เราแค่ต้องหาชื่อฟังก์ชั่นหรือวิธีการแบบสั้นดังนั้นฉันจึงเลือกวิธีใหญ่ ()ภายในตัวสร้างสตริง ดังนั้นฉันสามารถเข้าถึงได้โดยตรงจากสตริงว่าง"".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)ที่จะสามารถทำลายมันได้โดยใช้\ .

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) และ unary @(รับองค์ประกอบแรก):

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

ลองใช้ออนไลน์

ค่อนข้างน่าเบื่อเนื่องจากความคิดเห็นของบรรทัด สิ่งเดียวที่น่าสนใจคือการใช้ nullSystemอ้างอิงแบบซึ่งดูเหมือนว่ามีความจำเป็นเพื่อที่จะพิมพ์ออกมาในมาตรฐานที่ต่ำกว่า 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"
        );
}