Hãy đứng trên hàng dài


23

Gần đây, ai đó đã đề xuất các giới hạn nghiêm ngặt hơn cho độ dài dòng mặc định của Python:

Rõ ràng, không có chương trình nào nên sử dụng hơn 80 ký tự trên mỗi dòng, vì nhiều lý do. Trước hết, để dễ đọc và dễ bảo trì, điều quan trọng là phải có một tiêu chuẩn vững chắc, vì vậy chúng tôi có thể điều chỉnh độ rộng của trình soạn thảo văn bản của mình một cách thích hợp. Là một lợi ích thứ cấp, mã có thể dễ dàng được chuyển vào phương tiện có thể có các hạn chế và khi việc thêm ngắt dòng có thể gây mất tập trung, như các trang in để xem xét trong cuộc họp hoặc thẻ đục lỗ.

Nhưng 80 ký tự có quá cao không? Một số gợi ý 79, hoặc thậm chí thấp đến 75, cho phép thiết bị đầu cuối rộng 80 ký tự phù hợp với mã với một vài cột dành cho số dòng. Rõ ràng, cuối cùng, thấp hơn là tốt hơn, vì các giới hạn thấp hơn cho phép mã được sử dụng trong nhiều tình huống hơn mà không cần định dạng lại.

Giới thiệu chuẩn max6

Mục tiêu của bạn là tìm và thể hiện độ dài dòng tối thiểu theo Ngôn ngữ yêu thích của bạn bằng cách viết một biến thể FizzBuzz với số lượng ký tự ít nhất trong bất kỳ dòng nào.

Đầu vào

Một số nguyên, n , thông qua bất kỳ phương thức mong muốn.

Đầu ra

In các số từ 1 đến n , ( n 1, n ∈) cách nhau bởi các ngắt dòng, ngoại trừ:

  • cho bội số của 3 bản in "Apple"
  • cho bội số của 5 bản in "Pie"
  • cho bội số của cả 3 và 5 in "ApplePie"

Chấm điểm

Độ dài dòng tối đa tính bằng byte, không bao gồm ngắt dòng (Cr, CrLf, Lf hoặc ngắt tiêu chuẩn hệ thống khác, chỉ định, như mong muốn) và tổng chiều dài mã tính theo byte như một bộ ngắt.

Quy tắc

Tất cả các ngắt dòng phải có ý nghĩa. Ngắt dòng có thể được loại bỏ và các dòng liền kề được nối trực tiếp mà không ảnh hưởng đến đầu ra, phải được loại bỏ.


2
Về hạn chế dòng mới, nếu loại bỏ một nhóm dòng mới cụ thể khiến nó hoạt động nhưng loại bỏ bất kỳ dòng mới nào khiến nó bị lỗi, thì có phải loại bỏ dòng mới không? Chúng rất quan trọng về mặt cú pháp chỉ là việc loại bỏ một số trong số chúng hủy bỏ tầm quan trọng của chúng.
Thuật sĩ lúa mì

3
Không chắc chắn tôi cảm thấy thế nào về quy tắc dòng mới "có ý nghĩa". Khi nói đến cú pháp hợp pháp, phần lớn các ngôn ngữ lập trình không quan tâm đến các dòng mới và sẽ cho phép bạn viết toàn bộ chương trình trên một dòng - chỉ cần xem hầu hết các giải pháp chơi mã ở đây :-P
nderscore

1
Tại sao thay đổi nó thành Apple Pie thay vì tiêu chuẩn
Rohan Jhunjhunwala

5
@RohanJhunjhunwala Để ngăn chặn sử dụng các lệnh FizzBuzz dựng sẵn.
Ørjan Johansen

2
+1 Đây thực sự là một ý tưởng tốt cho một thử thách golf mã! Tuy nhiên, số lượng ít ký tự trên mỗi dòng có vẻ không thực tế Tôi vẫn thích nó
George Willcox

Câu trả lời:


17

> <> , 1 byte mỗi dòng, 243 161 135 byte

-26 byte nhờ Jo King!

Ngôn ngữ 2D FTW! Mặc dù viết các vòng lặp và các nhánh sử dụng các hướng dẫn goto thay vì cấu trúc 2D không thú vị.

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

Hãy thử trực tuyến! , hoặc xem nó tại sân chơi cá !

Cá bơi xuống dưới dọc theo mã, sử dụng gotos có điều kiện để bỏ qua mọi thứ tùy thuộc vào những gì phân chia tích lũy.

Tôi tin rằng điều này đáp ứng được thông số kỹ thuật: bất kỳ dòng mới nào bị loại bỏ, cá luôn đạt điểm ban đầu v(hướng dẫn thay đổi hướng duy nhất hiện tại), vì vậy cá luôn bơi xuống trong cột đầu tiên. Do đó, việc xóa một dòng mới có tác dụng đơn giản là xóa ký tự tiếp theo khỏi đường dẫn của cá và tôi không nghĩ bạn có thể xóa bất kỳ ký tự nào mà không thay đổi đầu ra.


Có bao nhiêu byte?
L3viathan

1
@ L3viathan, đó là 243 byte. (Tôi sẽ chỉnh sửa nó trong.)
Không phải là một cái cây

1
@ L3viathan: Tôi đã sắp xếp lại một chút và bây giờ là 161 byte!
Không phải là một cái cây

:( Tôi không nghĩ rằng tôi có thể đánh golf câu trả lời của mình quá nhiều ...
L3viathan

1
135 byte . và đây là phiên bản nằm ngang để tham khảo
Jo King

18

Haskell , 3 byte / dòng, 494 471 470 463 453 450 461 byte

CHỈNH SỬA:

  • -26 byte: Đã xóa một số ngắt dòng dự phòng và các dấu nhận xét liên quan của chúng và thay đổi -1+xthành x-1.
  • +3 byte: Rất tiếc, cần thêm --dòng sau x-.
  • -1 byte: Đang fsử dụng c 47:[]thay vì [c 47&0].
  • -7 byte: Di chuyển xử lý dòng mới đến w.
  • -10 byte: Inline a="Apple"p="Pie"in #và sử dụng đệ quy giả cho 15 trường hợp.
  • -3 byte: Inline win f. Loại bỏ dư thừa --giữa x15.
  • +11 byte: Rất tiếc lần nữa! Lý thuyết khoảng cách chuỗi của tôi có một lỗ. Đã sửa lỗi bằng cách giới thiệu %chức năng. Cuối cùng thực hiện một số thử nghiệm tự động để đảm bảo không có nhiều bất ngờ nữa.

fmất một Intvà trả về 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}

Hãy thử trực tuyến!

Kiểm tra hạn chế nguồn! (Dòng 70 được loại trừ khỏi thử nghiệm vì loại bỏ dòng mới của nó gây ra một vòng lặp vô hạn mà không có đầu ra.)

Phiên bản với các thủ thuật vắt quan trọng nhất đã bị xóa:

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

Làm thế nào nó hoạt động

  • Mã này được viết trong chế độ không nhạy cảm thụt đầu dòng hiếm khi được sử dụng của Haskell, được kích hoạt, ví dụ như bằng cách bao quanh toàn bộ chương trình với {}. Vì tôi thực sự xác định một hàm chứ không phải là toàn bộ chương trình, tôi không chắc chắn cách đếm byte; Tôi đã chọn để phòng thủ đếm cả các {}s và thêm ;tách khai (sau này thường là một newline trong chế độ Haskell bình thường.)
  • Thủ thuật chính để tạo dòng mới "có ý nghĩa" là --nhận xét dòng, làm cho dòng mới tiếp theo không thể tháo rời và cũng là dòng mới trước trong trường hợp khi dòng trước kết thúc bằng ký tự toán tử (không phải là một phần của nhận xét dòng) .
  • Thủ thuật thứ hai là "các khoảng trống chuỗi", một chuỗi khoảng trắng giữa các \dấu gạch chéo ngược trong chuỗi ký tự chuỗi, được thụt vào để tiếp tục dòng với sự thụt dòng có thể. Một khoảng cách chuỗi với dấu phân cách được xóa khỏi chuỗi được phân tích cú pháp.
    • Nếu dòng mới của khoảng cách chuỗi được loại bỏ, nó sẽ trở thành dấu gạch chéo ngược được thêm vào trong chuỗi. Cho "Apple""Pie"điều này hiển thị trực tiếp trong đầu ra. Cho "8""9"khớp mẫu được sử dụng để đưa ra lỗi nếu chuỗi có nhiều hơn một ký tự.
  • Thủ thuật thứ ba là các toán tử &%toán tử, cho phép buộc một dòng kết thúc bằng ký tự toán tử cho thủ thuật đầu tiên. Chúng tôi cần điều này để kết thúc chuỗi ký tự, bởi vì \"quá rộng để nối thêm --.
    • &là cái chung, định nghĩa sao cho x&y=x.
    • %được định nghĩa sao cho [a]%y=a, cho phép nó thay thế !!0và đồng thời thực thi rằng đối số chuỗi của nó phải có độ dài 1.
  • Ký tự dòng mới đặt ra một vấn đề đặc biệt, vì \ndường như không thể phù hợp với một chuỗi ký tự chỉ có 3 byte trên dòng.
    • Do đó, dễ dàng xác định hơn c x=["9"%0,"8"%0..]!!xđược sử dụng để chuyển đổi từ một Intsang một ký tự, đếm từ chữ số '9'trở xuống.
  • Bởi vì showcó bốn ký tự, đầu ra số phải được thực hiện bằng tay.
    • dlà một danh sách các chuỗi chữ số "1".."9".
    • nlà một danh sách vô hạn các biểu diễn số ["1","2","3",...]được định nghĩa đệ quy bằng cách sử dụng d.
  • #chuyển đổi một Int xmẫu ApplePie của nó cho một cuộc tranh cãi đầu tiên bổ sung mà là gcdcủa x15.

6

Haskell , 7 byte / dòng, 339 byte

Yêu cầu ngắt dòng có ý nghĩa làm cho điều này trở thành một thách thức không cần thiết trong Haskell. Hầu như không có cách nào để chèn ngắt dòng không thể xóa được, vì vậy mọi thứ phải được thực hiện với các tuyên bố nhỏ hợp pháp.

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

Hãy thử trực tuyến!


6

Jelly , 3 2 byte / dòng, 106 80 56 byte

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

Các hàng và cột của chuỗi ký tự được chuyển đổi, do đó việc loại bỏ các dòng mới làm rối trật tự của chúng.

Các dòng còn lại là các liên kết / hàm riêng biệt và chứa các lệnh gọi hàm ( ¢), vì vậy chúng chỉ có thể được nối nếu các lệnh gọi hàm cũng bị loại bỏ.

Hãy thử trực tuyến!


6

TI-BASIC, 4 byte mỗi dòng

Vì mục tiêu chỉ là để giảm thiểu độ dài dòng tối đa, một số dòng dài hơn mức cần thiết, nhưng nhỏ nhất tôi có thể tạo dòng dài nhất là 4 byte. Do đó, tôi cảm thấy nó sẽ làm cho mã dễ đọc hơn nếu tôi hợp nhất các dòng có thể được kết hợp mà không vượt quá 4 byte.

"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

Bị đánh cắp

"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

Về ngôn ngữ và giới hạn

TI-BASIC là ngôn ngữ được mã hóa và trong trường hợp này, mỗi mã thông báo là 1 byte ngoại trừ các StrNbiến là 2 byte. Ngoài ra, bạn có thể rời khỏi việc đóng dấu ngoặc đơn trong hầu hết thời gian. Các remainder(chức năng là 2 byte, vì vậy sử dụng nó sẽ đòi hỏi ít nhất 5 byte (một cho chức năng, hai cho các đối số, và một cho các dấu phẩy trong remainder(I,3). Thay vào đó, tôi đã sử dụng các hàm fPart(và các not(hàm để làm cho nó ngắn hơn, cả hai mã thông báo 1 byte. Ngoài ra, bạn có thể thấy tôi đã sử dụng biến tích hợp Anskhá nhiều, vì bất kỳ biểu thức nào được đánh giá trên một dòng đều tự động được lưu trữ vào nó. Vì vậy, tôi có thể lưu một vài byte bằng cách tách các biểu thức và bài tập.

Một chiến lược khác rõ ràng là giảm thiểu các bài tập chuỗi. Phương pháp của tôi để làm như vậy phụ thuộc vào độ dài dòng tối đa trong phần còn lại của mã. Khi tôi xác định nó là 4 byte, tôi có thể nhồi nhét càng nhiều chuỗi trên cùng một dòng càng tốt để giảm thiểu số lượng bài tập tôi cần. Tôi đã làm điều này vì mục đích dễ đọc.

Các yếu tố giới hạn trong mã này là các phép gán cho các biến chuỗi và nối với các biến chuỗi. Các dòng Ans→Str1Str1+Anscả hai đều có tổng cộng 4 byte. Tôi sẽ phải tìm cách loại bỏ hoàn toàn các biến chuỗi để giảm thiểu tối đa độ dài dòng tối đa trong mã của tôi. Mọi thứ khác có thể được rút ngắn tối đa 3 byte hoặc ít hơn trên mỗi dòng.

Vấn đề nằm ở việc gán cho các biến số, chẳng hạn như 1→I. Bạn không thể đánh gôn thêm nữa mà không bằng cách nào đó đưa ra giải pháp mà không có các biến không vượt quá 2 byte chiều dài dòng. Điều đó xảy ra là không thể đối với thử thách này.

Toán tử nhị phân như +yêu cầu ký hiệu toán tử và các đối số trái và phải. Vì vậy, nếu không có điều này, bạn sẽ không thể nối chuỗi. Nếu không nối chuỗi, sẽ không có cách nào để hiển thị các chuỗi cần thiết cho chương trình này để hoàn thành thử thách mà không vượt quá 2 byte chiều dài dòng. Do đó, giới hạn lý thuyết cho thử thách này trong ngôn ngữ này sẽ là 3 byte trên mỗi dòng, điều mà tôi không thể đạt được.


Nhưng dòng dài nhất trong phiên bản chơi gôn là 10 byteIf A and B
jmarkmurphy

@jmarkmurphy TI-BASIC là ngôn ngữ được mã hóa và hầu hết các mã thông báo được biểu thị bằng một byte đơn. Tôi đã đề cập rằng trong mô tả của tôi về giải pháp. Bạn có thể đọc thêm về điều đó trên wiki này .
kamoroso94

Nhưng tiền đề là các biên tập viên nên cho phép số lượng ký tự tối thiểu trên mỗi dòng. Tôi nghi ngờ rằng bạn đang gõ mã thông báo bằng trình chỉnh sửa. Và tôi không nghĩ rằng bất kỳ ngôn ngữ nào khác không được hiểu hoàn toàn là sử dụng một đối tượng được biên dịch hoặc số byte được mã hóa.
jmarkmurphy

@jmarkmurphy thực sự bạn gõ mã thông báo trong trình chỉnh sửa. Mã Ansthông báo là 1 byte, trong khi ba ký tự liên tiếp lần lượt Anslà 1, 2 và 2 byte cho tổng số 5. ​​Đây không phải là chuỗi ASCII, nó thực sự là mã thông báo khi bạn nhập nó vào máy tính.
kamoroso94

Có một số sự đồng thuận về điều này đã có trên meta .
kamoroso94

6

C (gcc) , 2 byte mỗi dòng, 374 368 320 310 262 byte

Tôi cho rằng nó có thể được chơi golf nhiều hơn một chút. Dấu gạch chéo ngược thoát khỏi dòng mới làm cho nó trở nên tầm thường.

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

Hãy thử trực tuyến!


@ Ørjan Johansen Ah, hoàn toàn đúng.
dạ dày

Bạn có thể loại bỏ rất nhiều dấu gạch chéo ngược, làm giảm điểm số tie-break của bạn. Ngoài ra, không cần tách các mã thông báo hai byte như &&.
Toby Speight


5

PHP 7, 2 byte mỗi dòng

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

Làm thế nào mà làm việc với các dấu chấm?
L3viathan

@ L3viathan Dots biểu thị sự kết hợp. Chúng được sử dụng để xây dựng chuỗi dài từ các ký tự đơn.
dùng63956

Tôi biết điều đó, nhưng PHP chỉ tạo ra các chuỗi từ các tên biến không được gán, hay nó hoạt động như thế nào? Tôi thấy không có trích dẫn chars.
L3viathan

2
@ L3viathan Những nhân vật đó là hằng số. Nếu một hằng số chưa được xác định, PHP sử dụng tên của nó làm giá trị.
dùng63956

5

Aceto , 1 byte mỗi dòng, 230 byte

Chà, thật vui khi viết. Là một loại nấm, các cấu trúc điều khiển của Aceto phụ thuộc rất nhiều vào bản chất 2D của nó, nhưng chúng ta có thể làm việc xung quanh đó với rất nhiều lối thoát có điều kiện ( `). Vấn đề duy nhất với chúng là chúng ảnh hưởng đến lệnh tiếp theo, bất kể sự hiện diện của nó (tất cả các chương trình Aceto là hình vuông, bên trong), đó là lý do tại sao chúng ta cần căn chỉnh chương trình tại một số nơi bằng cách chèn các dòng trống vào một số điểm.

Chuỗi ký tự thực sự không thể được sử dụng, nhưng chữ char có thể (ở một số nơi; một lần nữa, chúng ta cần căn chỉnh chúng).

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

Được gọi với 20, bản in này:

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

Tất cả các ngắt dòng phải có ý nghĩa. Ngắt dòng có thể được loại bỏ và các dòng liền kề được nối mà không có tác động đến đầu ra, phải được loại bỏ.

Điều này không bao giờ là trường hợp ở đây vì nó chạy từ dưới lên trên.

Có ít nhất một nơi mà chúng ta có thể tiết kiệm 2 byte (bằng cách thay thế `Xbằng một |hoặc #), nhưng tôi đã giữ nó vì đó là do chi phí thời gian chạy liên quan đến việc chạy qua một đường cong Hilbert tương đối lớn.

Tôi cũng bỏ qua yêu cầu ngầm đối với việc sử dụng \rhoặc \r\ndòng mới vì tôi nghĩ đó là một lỗi vô ý của OP. Nếu có chỉnh sửa hoặc nhận xét củng cố yêu cầu này, tôi có thể thay đổi nó mà không gặp nhiều khó khăn khi sử dụng dòng mới CR thay thế.

Bytecount dựa trên mã hóa mã hóa của Aceto; Latin-7, trong đó £là một byte đơn.


Re Giả sử ba chuỗi trên stack [...]thay thế này là trái như một bài tập cho người đọc. : Vui lòng cung cấp mã đầy đủ cần thiết để giải quyết công việc trong tay. Như là, giải pháp của bạn là không đầy đủ. Nó cũng thiếu số byte, là bộ ngắt kết nối cho các giải pháp có số điểm là 1.
Dennis

@Dennis Bây giờ tôi đã chỉnh sửa câu trả lời để cung cấp mã làm việc đầy đủ.
L3viathan

5

Perl 5 , 2 byte mỗi dòng, 182 byte

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

Hãy thử trực tuyến!

Cú pháp của Perl rất dễ tha thứ, vì vậy rất nhiều khoảng trống có thể được thêm vào mã và các bình luận được thêm vào, điều này làm cho ý tưởng cốt lõi khá đơn giản. Mục đích chính của mã này là xây dựng một chuỗi chứa mã mà chúng ta muốn chạy và evalnó. Trong Perl, có thể gọi một hàm bằng cách sử dụng một chuỗi hoặc biến bằng &{...}ký hiệu, tuy nhiên, không may evallà không thể gọi được ở dạng này, nhưng evalbytes, miễn là bạn gọi nó qua CORE::không gian tên. Xây dựng chuỗi đó khá đơn giản và chương trình được truyền trực tiếp vào cuộc gọi này. Các chuỗi được xây dựng bằng cách sử dụng các dòng mới như là một phần của XOR, để xây dựng các chuỗi này tôi đã sử dụng tập lệnh này. Để giữ tính hợp lệ này, một vài nơi đã phải đặt bình luận, do đó việc xóa các dòng mới sẽ dẫn đến mã không hoạt động.

Thói quen FizzBuzz được lấy từ câu trả lời tuyệt vời của Primo .


Perl 5 , 1 byte mỗi dòng, 172 byte

Vì vậy, tôi (bây giờ) biết điều này là không hợp lệ , bởi vì một loạt các dòng mới có thể bị xóa, nhưng vì đây là cách tiếp cận ban đầu của tôi đối với vấn đề tôi đang thêm nó. Thật vui khi thấy bạn có thể đẩy cú pháp của Perl bao xa! Tôi rất thích vấn đề này bằng chính giá trị của nó, mặc dù nó không hợp lệ.

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

Hãy thử trực tuyến!


Điều này có phá vỡ quy tắc "Tất cả các ngắt dòng phải có ý nghĩa" không?
12Me21

@ 12Me21 yeah, tôi vừa mới nhìn vào đó. Vì vậy, cái đầu tiên sẽ phá vỡ nó nếu bị loại bỏ, nhưng một số cái khác thực sự có thể bị xóa, đặt nó ở độ dài 2. Chết tiệt, tôi đã mất nhiều thời gian để có được cách tiếp cận làm việc với một char trên mỗi dòng!
Dom Hastings

@ 12Me21 Tôi nghĩ rằng tôi đã có một giải pháp hoạt động được 2 giờ rồi, tôi đã thêm một phiên bản golf có độ dài 1 byte kể từ khi tôi dành thời gian để thực hiện nó, các quy tắc chết tiệt! :)
Dom Hastings

5

SmileBASIC, 9 7 byte mỗi dòng, 159 155 154 152 byte

Đây là một thử thách thực sự thú vị. Thật không may, quy tắc chống lại ngắt dòng không cần thiết gây ra một số vấn đề, (mặc dù may mắn là nó không ảnh hưởng đến độ dài dòng tối đa ở đây.) Tôi đã phải thêm nhận xét giữa các dòng như A%=I/3A=A%*3, vì A%=I/3A=A%*3được phân tích chính xác trong SB. Tôi đã có thể sử dụng một mẹo để bỏ qua một số nhận xét, vì thay thế Abằng Elàm cho dòng đó không hợp lệ ( ETôi nghĩ nó có liên quan đến các số được viết bằng ký hiệu, tôi nghĩ. 3EĐược coi là một số không hợp lệ thay vì một số và một tên biến.)

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

Hạn chế lớn nhất ở đây là nhận đầu vào. INPUT xlà cách đơn giản nhất được phép, phương án thay thế để xác định hàm có giá trị đầu vào như thế DEF F xnhưng đó vẫn là 7 ký tự. Làm một tuyên bố có điều kiện cũng khó khăn; Tôi không thể nghĩ bất cứ điều gì ngắn hơn WHILE x.


1
Nếu A%=I/3A=A%*3có giá trị về mặt cú pháp nhưng bị hỏng một cách hợp lý, bạn không cần char bình luận.
Nick T

Nó được phân tích chính xác như A%=I/3A=A%*3, vì vậy bình luận là bắt buộc.
12Me21

3

JavaScript (ES6), 3 byte mỗi dòng

Sử dụng biến toàn cục topđể truy cập vào windowđối tượng, từ đó chúng tôi evalmã sau đây:

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

Bạn sẽ phải chạy nó trong bảng điều khiển vì topkhông thể truy cập được từ Stack Snippet được đóng hộp cát.


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

3

C #, 9 byte mỗi dòng, 248 242 230 byte

Vì C # không quan tâm đến việc ngắt dòng, nên nó cần một nhận xét trực tuyến ở cuối gần như (cảm ơn Ørjan Johansen) mỗi dòng để tuân thủ các quy tắc. Chương trình này hy vọng n là một đối số dòng lệnh. Đây là càng nhiều dòng mới không thể xóa càng tốt:

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

Nhưng vì dòng dài nhất là 9 byte, các dòng khác cũng có thể dài như vậy, loại bỏ một số byte:

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

Tôi đã giải thích sự kết hợp là "không có khoảng cách giữa", vì vậy bạn không cần //giữa các mã thông báo sẽ hợp nhất với nhau, như staticvoid.
Ørjan Johansen

@ RjanJohansen Cảm ơn! Đã lưu 6 byte
Arthur Rump

Tôi nghĩ có lẽ bạn có thể tiết kiệm nhiều byte hơn bằng cách sắp xếp lại var s="";if// (i%3==0// )s+=// "Apple"// ;if(i%5//.
Ørjan Johansen

Và có một cơ hội tương tự để chuyển Atừ dòng đầu tiên sang dòng thứ hai.
Ørjan Johansen

Và cũng đã lưu 3 byte bằng cách thay đổi "\ n" thành @ "", với trích dẫn thứ hai trên một dòng mới, làm cho dòng mới đó cũng được yêu cầu.
Arthur Rump

2

Python 2, 5 byte / dòng, 93 byte

Tiêu chuẩn max6 đã lỗi thời.

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

Hãy thử trực tuyến!

Python 2 và 3, 5 byte / dòng, 100 byte

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

Hãy thử trực tuyến!


2

JavaScript, tối đa 6 byte / dòng, 528 byte

Ý tưởng xé toạc từ đây .

Mã bị xé từ đây .

Cảm ơn Anders Kaseorg vì đã g=evaltiết kiệm một byte trên mỗi dòng.

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)

Vô song:

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

a=""+\n"f"+\n"o"+ ...và kết thúc bằng eval(\na)một chút ngắn hơn
Value Ink

Các quy tắc thay đổi một chút (ApplePie, lấy đầu vào), nhưng lược đồ của bạn vẫn phải hợp lệ.
Nick T

Thay đổi quy tắc làm mất hiệu lực đề xuất của @ ValueInk, nhưng bạn vẫn có thể kết thúc bằng f=evalf(a).
Anders Kaseorg

@AndersKaseorg cảm ơn bạn :) đã không nghĩ về điều đó
Stephen

1
Bạn có thể lưu một byte bằng cách đặt 2 ký tự trong chuỗi trên dòng đầu tiên.
12Me21

2

PHP, 4 byte / dòng

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

Hãy thử trực tuyến!


Tất cả các ngắt dòng phải có ý nghĩa. Ngắt dòng có thể được loại bỏ và các dòng liền kề được nối mà không có tác động đến đầu ra, phải được loại bỏ.
Julian Wolf

@JulianWolf Tôi đã thay đổi nó
Jörg Hülsermann

2

APL (Dyalog) , 5 byte mỗi dòng

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''
M3|⍵
M0=M
OM/A
M5|⍵
M0=M
MM/P
O,←M
M←⍴O
M0=M
MM/⍵
O,←M
⎕←O
}¨⍳⎕

Hãy thử trực tuyến!


2

Võng mạc , 4 byte / dòng

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

Hãy thử trực tuyến!


2

R , 10 byte mỗi dòng, 800 byte

Quy tắc "ngắt dòng có ý nghĩa" đã làm cho thách thức này. Hiện tại điều này chỉ đánh vần mã fizzbuzz thành một chuỗi và sau đó thực thi nó.

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)

Hãy thử trực tuyến!

Đây là mã ApplePie được ghép nối (được chuyển thể từ golf của MickyT tại đây ).

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

Và phiên bản không mã hóa của mã phân tích cú pháp:

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

Ở đây tôi sử dụng toStringđể nối danh sách các ký hiệu athành một chuỗi. Tuy nhiên, hành vi mặc định là tách riêng từng biểu tượng ,, vì vậy chúng tôi gọi gsubđể thay thế chúng bằng null. Sau đó, chúng tôi chuyển nó đến parseevalđể làm công việc bẩn thỉu.

Có thể là có một cách tiếp cận mà không sử dụng phương pháp này chuỗi phân tích và chỉ thẳng lên dụng cụ fizzbuzz, nhưng có vẻ như với tôi rằng việc sử dụng forhoặc whilehoặc xác định một functionnhu cầu đường dài hơn phương pháp hiện hành.


2

Ruby, 10 5 byte / dòng, 354 214 byte

-140 byte từ điểm số thô từ @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}"

Làm thế nào nó hoạt động

Ruby sẽ tự động nối các chuỗi ký tự chuỗi (trừ các ký tự đơn ký tự như ?a) trong cùng một câu lệnh. Điều đó có nghĩa x = "a" 'b' "c" %q{d}là tương đương với x = "abcd". Chúng tôi sử dụng điều này để phân chia mã giống như FizzBuzz thành các chuỗi nhỏ hơn nhiều để gọi evalvới, vì +sẽ làm mất hiệu lực chương trình do quy tắc loại bỏ dòng mới, nhưng \sẽ gây ra lỗi cú pháp nếu dòng mới bị loại bỏ!


Tôi vừa định gửi một cái gì đó tương tự
dkudriavtsev

Các quy tắc thay đổi một chút ('ApplePie, lấy đầu vào), nhưng lược đồ của bạn vẫn hợp lệ.
Nick T

Bạn có thể lưu rất nhiều byte bằng cách thêm hai ký tự vào chuỗi trên mỗi dòng.
NieDzejkob

@NieDzejkob cơ chế tính điểm chính ở đây là byte trên mỗi dòng, có nghĩa là tốt hơn là hy sinh tổng số byte để giảm độ dài dòng.
Mực giá trị

@NieDzejkob nvm Tôi hiểu ý của bạn bây giờ, đó là vì evaldòng ban đầu dài hơn phần còn lại, phải không?
Mực giá trị

1

Julia 0,6 , 5 byte mỗi dòng, tổng cộng 168 byte

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)

Hãy thử trực tuyến!

Việc printmang điều này không thể tránh khỏi (afaict) vào lãnh thổ 5 byte trên mỗi dòng.

Ung dung:

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

*là toán tử nối chuỗi, do đó, a*p*"\n"tạo thành "ApplePie \ n". |>là toán tử chuỗi chức năng (/ piping), do đó, chuỗi được chọn sẽ được gửi làm đối số print. Cái sinnày không được sử dụng, nó chỉ ở đó bởi vì printcần phải ở trong một mảng để có khoảng trắng đáng kể sau nó (sử dụng #thủ thuật sau nó sẽ đưa số byte tối đa trên mỗi dòng lên 6).


Nếu chỉ đơn giản trả về đầu ra dưới dạng một mảng được cho phép, nó có thể được thực hiện với tối đa 4 byte trên mỗi dòng:

Julia 0,6 , 4 byte mỗi dòng, tổng cộng 152 byte

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

Hãy thử trực tuyến!

Một hàm lấy n và trả về một mảng chứa đầu ra dự kiến. Độ dài dòng tối đa ở đây bị hạn chế bởi n->- Julia cần điều đó trong một dòng duy nhất để phân tích nó đúng như là bắt đầu của lambda.


1

Pascal (FPC) -Sew , 6 byte mỗi dòng, 348 320 byte

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.

Hãy thử trực tuyến!

Sử dụng FPC để nhận 6 byte mỗi dòng; không có nó, kết quả sẽ tồi tệ hơn nhiều Đây là chiều rộng dòng nhỏ nhất có thể vì sau writephải là ;hoặc ((hoặc khoảng trắng không cần thiết), vì vậy một bình luận đặc biệt được chèn để tránh điều này. Các tính năng từ FPC có ảnh hưởng đến câu trả lời này là:

  1. // - bắt đầu bình luận một dòng.
  2. Chặn ý kiến ​​dưới dạng {$<something>...}là chỉ thị của trình biên dịch. Nếu lệnh không tồn tại, FPC sẽ đưa ra cảnh báo (và cả trên {$ ...}). Trong chương trình này, {$được phân tách bằng một dòng mới sẽ đưa ra cảnh báo khi bị xóa.
  3. -Sew- Trình biên dịch cũng tạm dừng sau các cảnh báo để {$tham gia dừng quá trình biên dịch.

1

Japt , 3 byte mỗi dòng

Gần như được quản lý để giảm xuống còn hai byte trên mỗi dòng, nhưng lợi nhuận từ bản đồ sẽ bị phá vỡ nếu theo sau đó là một dòng mới.
Bản thân việc triển khai FizzBuzz là từ luồng FizzBuzz chính tắc .


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

Hãy thử trực tuyến!


1

LOLCODE , 18 8 byte mỗi dòng, tổng cộng 303 byte

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

Hãy thử trực tuyến!

-10 byte mỗi dòng sử dụng ký tự tiếp tục dòng , nhờ rjan Johansen!


Bạn có thể giảm xuống còn 8 với ký tự tiếp tục dòng. Hãy thử trực tuyến!
Ørjan Johansen

Tôi đang học được điều gì đó mới mẻ về những esolang này mỗi ngày. Cảm ơn, Oerjan!
JosiahRyanW

0

Python 2 , 5 byte / dòng

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

Hãy thử trực tuyến!


Cẩn thận! 'z\"'phương tiện điều tương tự như 'z\"', vì vậy các phương tiện quy tắc xuống dòng không cần thiết bạn không được phép để bắt đầu một dòng tiếp nối trong chuỗi với ".
Anders Kaseorg

@AndersKaseorg đã thực hiện r'...'ngay bây giờ
Martmists

Cái này ném a SyntaxError.
Erik the Outgolfer

TIO dừng một số sớm. Ngoài ra, các quy tắc thay đổi từ việc sử dụngFizzBuzz sang sử dụngApplePie .
Ørjan Johansen

0

JavaScript (ECMAScript6), 2 byte mỗi dòng

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


Giải thích dài

Cách chúng ta có thể làm cho các dòng ngắn hơn là chuyển đổi mã thành một chuỗi và thoát khỏi các đầu dòng, điều này sẽ áp đặt giới hạn 2byte trên mỗi dòng.

Vì vậy, alert(1)trở thành

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

Nhưng bây giờ mã của bạn là một chuỗi vì vậy chúng ta cần thực thi chuỗi dưới dạng mã. Tôi biết ít nhất 4 cách bạn có thể thực thi chuỗi dưới dạng mã:

  1. eval (mã) . Mất ít nhất 5 byte để gọieval(
  2. setTimeout (mã, thời gian chờ) . Chạy chức năng không đồng bộ, nhưng tùy chọn nếu bạn vượt qua một chuỗi, nó sẽ gọi eval bên trong.
  3. Bạn có thể tận dụng DOM và đặt mã của bạn vào trong một onclick=""thuộc tính, nhưng tôi không thể quản lý để làm cho phần tạo phần tử ngắn lại.
  4. Gọi hàm tạo Hàm mới Hàm mới () sẽ phân tích mã của bạn thành một hàm ẩn danh mà bạn có thể gọi sau (tôi đã sử dụng hàm này).

Tất cả các chức năng có nguồn gốc cuộc sống bên trong cửa sổ đối tượng và trong javascript bạn có thể truy cập vào thuộc tính đối tượng bằng cách sử dụng ký hiệu dấu chấm để eval()trở thành window.eval(), hoặc bạn có thể truy cập vào các thuộc tính bằng cách sử dụng ký hiệu khung window['eval']() . Bạn có thể tận dụng điều này để phá vỡ evalnhiều dòng bằng phương pháp được mô tả trước đó. Nhưng bạn vẫn phải gõ cửa sổ , một mẹo nhỏ là nếu bạn không ở trong khung, biến trên cùng cũng là cửa sổ, vì vậy window.eval trở thành top.eval (giảm 3 byte).

w=top
w['eval']

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

Vì vậy, điều này sẽ làm cho mã tối thiểu là 3 byte. Để tạo mã 2 byte tôi đã sử dụng hàm new Function(/*string*/);tạo, nhưng tôi phải sáng tạo để truy cập nó mà không phải gõ nó.

Đầu tiên, hàm tạo cho phép bạn gọi nó là hàm bỏ qua từ khóa mới, điều này làm giảm 4 byte nhưng nó cũng quan trọng vì một lý do khác. Gọi hàm tạo như một hàm vẫn trả về một thể hiện, điều này cho phép chúng ta chuyển new Function(code)sangFunction(code) . Một điều quan trọng khác là hàm tạo Hàm có một callphương thức cho phép bạn gọi bất kỳ hàm nào nhưng ghi đè tham chiếu này và chính hàm tạo Hàm là hàm mà bạn có thể gọi một phương thức trên đó Function.call(null, code).

Tất cả các hàm riêng là các thể hiện của hàm tạo Hàm và tất cả các đối tượng trong javascript đều có thuộc tính hàm tạo . Vì vậy, bạn có thể có quyền truy cập Hàm tạo trên bất kỳ hàm riêng nào như alert.constructorvà sử dụng phương thức gọi chúng ta có thể thực thi hàm tạo như một hàm. Bây giờ chúng ta có alert.constructor.call (null, code) trả về một hàm.

kết hợp những thứ trước đây chúng ta có thể biến nó thành alert['constructor']['call'](null, code)

Bây giờ chúng ta chỉ cần tìm một hàm hoặc phương thức có tên ngắn, vì vậy tôi chọn phương thức big () bên trong hàm tạo String. Vì vậy, tôi có thể truy cập nó trực tiếp từ một chuỗi trống"".big

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

Sau đó, tôi chỉ phá vỡ mọi thứ trong 2 byte

Ngắn erGiải thích (TLDR)

Tôi đang truy cập hàm tạo Hàm (mã) mới để phân tích chuỗi thay vì eval (mã) . Hàm tạo này có sẵn ở mọi hàm riêng bằng cách thực hiện bất kỳ Hàm nào. nhà xây dựng , thích alert.constructor===Function. Tôi đang sử dụng một hàm / phương thức bên trong String.prototype.big String.prototype.big.constructor.call(null, /*string*/) Nhưng truy cập trực tiếp từ một chuỗi ký tự "".bigvà chuyển nó thành ký hiệu ngoặc . ""['big']['constructor']['call'](0, CODE)để có thể phá vỡ nó bằng cách sử dụng \.


1
Thật không may, tôi nghĩ rằng điều này là không hợp lệ vì ví dụ như bất kỳ ngắt dòng nào giữa ']có thể được gỡ bỏ và chương trình vẫn sẽ chạy thành công.
darrylyeo

Tôi không thể nghĩ ra bất kỳ cách nào xung quanh điều này với chiều rộng là 2. Nhưng vì chúng ta có cách tiếp cận gần như giống hệt nhau , có lẽ bạn có thể thêm một phiên bản điều chỉnh của lời giải thích của mình vào câu trả lời của tôi, vì vậy không phải tất cả đã bị mất?
darrylyeo

0

Pip , 3 byte mỗi dòng, tổng cộng 72 byte

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

Hãy thử trực tuyến!

Pip cực kỳ linh hoạt về khoảng trắng, vì vậy chiến lược duy nhất có vẻ khả thi là tạo ra một chuỗi, sửa đổi nó theo cách yêu cầu các dòng mới không bị xáo trộn và đánh bại nó.

Chúng tôi tạo một chuỗi trong đó mọi ký tự khác là một dòng mới và lấy mọi ký tự khác của chuỗi đó bằng cách sử dụng UW(uneave) và unary @(lấy phần tử đầu tiên):

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

Kết quả @UWphải là mã ApplePie của chúng tôi, được điều chỉnh từ giải pháp FizzBuzz tại đây . Nếu bất kỳ dòng mới nào trong chuỗi bị xóa, điều này sẽ không dẫn đến mã đầy đủ, gây ra lỗi cú pháp hoặc đầu ra không chính xác.

Vẫn còn hai dòng mới bên ngoài chuỗi. Chúng tôi đã thực hiện những điều bắt buộc này bằng cách sử dụng Ytoán tử (yank) - ở đây hoạt động như một lệnh không - cùng với cách phân tích cú pháp Pip chạy các chữ cái viết hoa:

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

Vì vậy, nếu những dòng mới này bị xóa, chương trình sẽ phân tích cú pháp khác và không làm những gì nó được yêu cầu.


0

Java 8, 7 byte mỗi dòng, 171 byte

Một lambda void lấy một int. Tôi nghi ngờ điều này tuân theo yêu cầu liên quan đến dòng mới, nhưng tôi không thể chứng minh điều đó và việc xác minh nó bằng vũ lực sẽ mất khoảng một tháng trên máy tính của tôi. Vì vậy, nó đi.

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

Dùng thử trực tuyến

Khá nhàm chán do các bình luận dòng. Điều thú vị duy nhất ở đây là việc sử dụng một Systemtham chiếu null , dường như là cần thiết để in ra theo tiêu chuẩn dưới 8 byte mỗi dòng. Cũng lưu ý rằng printcuộc gọi phương thức là nút cổ chai.

Ungolfed không có ý kiến:

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"
        );
}
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.