Uzun çizgilere karşı durun


23

Son zamanlarda, birisi Python'un varsayılan satır uzunluğu için daha katı sınırlar önerdi:

Açıkçası, hiçbir program bir dizi nedenden ötürü, her satırda satır başına 80'den fazla karakter kullanmamalıdır. Öncelikle ve en önemlisi, okunabilirlik ve bakım için, sağlam bir standarda sahip olmak önemlidir, böylece metin editörlerimizin genişliğini uygun şekilde ayarlayabiliriz. İkincil bir avantaj olarak, kod kolayca kısıtlanabilecek bir ortama aktarılabilir ve bir toplantıda incelenmek üzere yazdırılan sayfalar veya delikli kartlar gibi satır kesmeleri eklemek dikkat dağıtıcı olabilir.

Ancak 80 karakter çok mu yüksek? Bazıları 80 karakterlik bir terminalin kod numarasına ayrılmış birkaç sütunla kodlanmasına izin vermek için 79, hatta 75 kadar düşük olduğunu öne sürüyor. Açıkçası, sonuçta, daha düşük, daha düşük limitler kodun yeniden biçimlendirme olmadan daha fazla durumda kullanılmasına izin verdiğinden daha iyidir.

Max6 standardına giriş

Amacınız, herhangi bir satıra en az sayıda karakter içeren bir FizzBuzz varyantı yazarak Favori Dilinizin gerektirdiği minimum satır uzunluğunu bulmak ve göstermektir.

Giriş

Bir tamsayı, n , istenen herhangi bir yöntem ile.

Çıktı

Sayıları 1 ile n arasında ( n ≥ 1, n ∈ ℤ), satır kesmeleriyle ayırarak, aşağıdakiler dışında yazdırın:

  • 3 katları için "Apple" baskısı
  • 5 katları için "Pasta" yazdır
  • hem 3 hem de 5 katları için "ApplePie" yazdırın

puanlama

Satır sonu (Cr, CrLf, Lf veya diğer sistem standardı sonu, istediğiniz şekilde belirtin) dahil olmayan maksimum satır uzunluğu ve bayt cinsinden toplam kod uzunluğunu tiebreaker olarak belirtin.

kurallar

Tüm satır sonları anlamlı olmalıdır. Çıkış üzerinde bir etki olmadan çıkarıldı ve bitişik hatları, birleştirilmiş olabilir satır sonu gerekir çıkarılabilir.


2
Yeni satır sınırlamasında, belirli bir yeni satır grubunun kaldırılması çalışmasına neden olur, ancak herhangi bir yeni satırın kaldırılması başarısız olmasına neden olursa, yeni satırlar kaldırılmalı mıdır? Sözdizimsel olarak önemlidirler, sadece bazılarını kaldırmanın önemini ortadan kaldırmasıdır.
Buğday Sihirbazı,

3
"Anlamlı" newlines kuralı hakkında ne düşündüğümden emin değilim. Yasal sözdizimi söz konusu olduğunda, programlama dillerinin büyük bir çoğunluğu yeni satırlara aldırış etmiyor ve tüm programı tek bir satıra yazmanıza izin veriyor - burada kod-golf çözümlerinin çoğuna bir göz atın :-P
nderscore

1
Neden standart yerine Elmalı Turta olarak değiştirilir
Rohan Jhunjhunwala

5
@RohanJhunjhunwala FizzBuzz yerleşik komutlarının kullanılmasını önlemek için.
Ørjan Johansen

2
+1 Bu bir kod golf mücadelesi için gerçekten iyi bir fikir! Satır başına az sayıda karakter olsa da pratik görünmüyor 😅 Ben yine de seviyorum
George Willcox

Yanıtlar:


17

> <> , Satır başına 1 bayt, 243 161 135 bayt

Jo King sayesinde -26 bayt!

2D dilleri FTW! Her ne kadar 2B yapının yerine halka ve talimat kullanarak döngü ve dal yazarken eğlenceli değildir.

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

Çevrimiçi deneyin! veya balık oyun alanında izleyin !

Balık, akümülatörü neyin ayırdığına bağlı olarak şeyleri atlamak için koşullu goto kullanarak kod boyunca aşağı doğru yüzer.

Bunun şartnameye uyduğuna inanıyorum: ne olursa olsun yeni satır çıkarılsa da, balıklar her zaman ilk başa v(tek yön değiştirme talimatı) vurur , böylece balık her zaman ilk sütunda aşağıya doğru yüzer. Böylece yeni bir çizgiyi silmek, bir sonraki karakteri balığın yolundan çıkarmanızın etkisine sahiptir ve çıktıyı değiştirmeden karakterlerden herhangi birini kaldırabileceğinizi sanmıyorum.


Bu kaç bayt?
L3viathan

1
@ L3viathan, 243 bayttır. (Bunu düzenleyeceğim.)
Bir ağaç değil

1
@ L3viathan: Ben biraz yeniden düzenledi ve şimdi 161 bayt!
Ağaç değil

:( Benim cevabımı bu kadar aşağı golf edebilirim sanmıyorum ...
L3viathan

1
135 bayt . ve burada referans için yatay versiyonu
Jo King,

18

Haskell , 3 bayt / satır, 494 471 470 463 453 450 461 bayt

DÜZENLE:

  • -26 bayt: Bazı gereksiz linebreaks ve bunlarla ilişkili açıklama işaretlerini kaldırıldı ve değiştirildi -1+xiçine x-1.
  • +3 bayt: Hata, --sonradan fazladan satır olması gerekiyor x-.
  • -1 bayt: Bunun yerine fkullanımda .c 47:[][c 47&0]
  • -7 bayt: Yeni satır işleme işlemini taşır w.
  • -10 bayt: Tekerlekli a="Apple"ve p="Pie"de #15 durum için boş bir özyinelemeye kullanın.
  • -3 bayt: Tekerlekli wiçinde f. Gereksiz çıkarın --arasında xve 15.
  • +11 bayt: Yine Hata! İplik aralığı teorimin bir deliği vardı. %İşlev tanıtımı ile düzeltildi . Sonunda artık sürpriz olmadığından emin olmak için bazı otomatik testler yapıldı.

fbir alır Intve bir döndürür 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}

Çevrimiçi deneyin!

Test kaynağı kısıtlamaları! (Satır 70 testten çıkarılmıştır, çünkü yeni hattının çıkarılması çıktı olmadan sonsuz bir döngüye neden olur.)

En önemli sıkıştırma hilelerinin kaldırıldığı versiyon:

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

Nasıl çalışır

  • Bu kod, örneğin, bütün bir programı çevreleyen tarafından tetiklenen daha nadir kullanılan girinti duyarsız Haskell modunda yazılmıştır {}. Aslında bütün bir programdan ziyade bir fonksiyon tanımladığım için baytları nasıl sayacağımdan emin değilim; Hem{} s hem de ekstra bir ;bildirim ayırıcıyı savunma olarak saymayı seçtim (ikincisi normal Haskell modunda genellikle yeni bir satır olur.)
  • "Anlamlı" yeni satır yapmak için ana hiledir --hat sonraki satır olmayan çıkarılabilir hale yorum, ve aynı zamanda bir önceki durumda satır zaman bir operatör karakter önceki hat uçları (kendisi bir çizgi açıklamaya dahil değildir) .
  • İkinci numara, \dize değişmezlerinde satır boşlukları için girintili, dize değişmezlerinde ters eğik çizgiler arasındaki boşluk dizisi olan "dizi boşlukları" dır . Sınırlayıcıları olan bir dize boşluğu ayrıştırılan dizeden kaldırılır.
    • Bir dize boşluğunun yeni satırı kaldırılırsa, dize eklenen bir ters eğik çizgi olur. Çünkü "Apple"ve "Pie"bu çıktıda doğrudan ortaya çıkıyor. İçin "8"ve "9"bir desen maç dize birden fazla karakter varsa bir hata vermek için kullanılır.
  • Üçüncü numara, ilk numara için bir operatör karakterinde bir çizginin bitmesine izin veren &ve %operatörleridir. String değişmezlerini sonlandırmak için buna ihtiyacımız var, çünkü \"eklemek için çok geniş --.
    • &Genel, öyle tanımlanır x&y=x.
    • %dize argümanının 1 uzunluğuna sahip olması gerektiği [a]%y=aşekilde değiştirilmesine !!0ve aynı anda uygulanmasına izin verecek şekilde tanımlanır .
  • Newline karakteri özel bir problem yaratır, çünkü \ndizgede sadece 3 bayt olan bir dizgeye sığması imkansız görünür.
    • Bu nedenle, daha kolay tanımlanabilen rakamdan aşağı doğru sayılarak bir karakterden karaktere c x=["9"%0,"8"%0..]!!xdönüştürmek için kullanılır .Int'9'
  • Çünkü showdört karakterdir, sayı çıktı elle uygulanması gerekir.
    • dbasamaklı dizelerin bir listesidir "1".."9".
    • n["1","2","3",...]özyinelemeli kullanılarak tanımlanmış sonsuz sayı gösterimlerinin listesidir d.
  • #Bir dönüştürür Int xonun applepie forma olan ekstra birinci argüman verilen gcdbir x15 ile.

6

Haskell , 7 bayt / satır, 339 bayt

Satır sonlarının anlamlı olmasının gerekliliği bunu Haskell'de önemsiz bir meydan okumaya dönüştürüyor. Kaldırılamayan satır sonları eklemenin neredeyse hiçbir yolu yoktur, bu yüzden her şey meşru küçük ifadelerle yapılmalıdır.

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

Çevrimiçi deneyin!


6

Jöle , 3 2 bayt / çizgi, 106 80 56 bayt

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

Dize değişmezinin satırları ve sütunları çevrilir, böylece yeni satırları kaldırmak onların sırasını bozar.

Kalan satırlar ayrı bağlantılar / işlevlerdir ve işlev çağrıları ( ¢) içerir; böylece işlev çağrıları da elimine edilirse birleştirilebilirler.

Çevrimiçi deneyin!


6

TI-BASIC, her satıra 4 bayt

Amaç, yalnızca maksimum satır uzunluğunu en aza indirgemek olduğundan, satırların bazıları olması gerekenden daha uzundur, ancak en uzun satırı yapabildiğim en küçük 4 bayttır. Bu nedenle, 4 baytı aşmadan birleştirilebilecek satırları birleştirirsem kodun okunmasını kolaylaştıracağını hissettim.

"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

Dil ve Sınırlamalar Hakkında

TI-BASIC tokenize bir dildir ve bu durumda, belirteçlerin her biri StrN2 bayt olan değişkenler hariç 1 bayttır. Ayrıca, çoğu zaman kapanış parantezleri bırakabilirsiniz. remainder(Fonksiyonu bu yüzden (bağımsız değişkenler için işlev için bir, iki ve virgül için bir en az 5 bayt gerektirir kullanarak, 2 byte remainder(I,3). Bunun yerine, fPart(ve not(her ikisini de 1 byte token olan kısaltmak için ve fonksiyonlarını kullandım . Ayrıca, dahili değişkeni Ansoldukça fazla kullandığımı görebilirsiniz , çünkü bir satırda değerlendirilen ifadeler otomatik olarak kendisine depolanır. Böylece, ifadeleri ve ödevleri bölerek bir kaç bayt kurtarabilirim.

Başka bir strateji açıkça dize atamalarını en aza indirmektir. Bunu yapma yöntemim, kodun geri kalanındaki maksimum satır uzunluğuna bağlıydı. 4 bayt olarak belirlediğimde, ihtiyacım olan ödev miktarını en aza indirgemek için, her bir dizgeden mümkün olduğu kadar aynı satırda sıkışabildim. Bunu okunabilirlik adına yaptım.

Bu koddaki sınırlayıcı faktörler string değişkenlerine yapılan atamalar ve string değişkenleriyle bitiştirmedir. Çizgiler Ans→Str1ve Str1+Ansher ikisi de toplamda 4 bayttır. Kodumdaki maksimum satır uzunluğunu daha da asgariye indirmek için string değişkenlerini tamamen ortadan kaldırmanın bir yolunu bulmak zorunda kalacağım. Diğer her şey satır başına en fazla 3 bayt veya daha kısa olabilir.

Buradaki problem, gibi sayısal değişkenlere atamada yatmaktadır 1→I. 2 bayttan uzun olmayan değişkenleri olmayan bir çözüm olmadan bir daha ortaya çıkmadan golf oynayamazsınız. Bu, bu zorluk için imkansız hale geliyor.

İkili operatörler +, operatör sembolünü ve sol ve sağ argümanları gerektirir. Yani bu olmadan, dizeleri birleştiremezsiniz. Dize bitiştirme olmadan, bu program için satır uzunluğunda 2 baytı aşmadan mücadeleyi tamamlamak için gereken dizeleri göstermenin bir yolu olmazdı. Bu nedenle, bu dilde bu zorluğun teorik sınırı, elde edemediğim her satıra 3 bayt olacaktır.


Ancak golf sürümündeki en uzun satır 10 bayttırIf A and B
jmarkmurphy

@jmarkmurphy TI-BASIC belirtilmiş bir dildir ve çoğu belirteç tek bir bayt ile temsil edilir. Ben çözüm tanımımda bahsetmiştim. Bununla ilgili daha fazla bilgiyi bu wikide okuyabilirsiniz .
kamoroso94

Ancak öncül, editörlerin satır başına en az sayıda karaktere izin vermesi gerektiği idi. Belirteçleri bir düzenleyiciyle yazdığınızdan şüpheliyim. Ve tamamen yorumlanmayan diğer dillerden herhangi birinin derlenmiş bir nesne veya tokenize bayt sayısı kullandığını sanmıyorum.
jmarkmurphy

@jmarkmurphy aslında düzenleyicideki belirteçleri yazarsınız. AnsÜç ardışık karakterler ise belirteç, 1 byte olan Anssen hesap üzerine yazarken kelimenin tam anlamıyla simge var, 1, 2, ve 2, ASCII dizesi değil 5'in olmak üzere toplam sırasıyla bayt.
kamoroso94

Bu konuda zaten meta üzerinde bir fikir birliği var .
kamoroso94

6

C (gcc) , satır başına 2 bayt, 374 368 320 310 262 bayt

Sanırım biraz daha golf oynayabilir. Yeni satırlardan kaçan ters eğik çizgiler onu önemsiz kılar.

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

Çevrimiçi deneyin!


@ Ørjan Johansen Ah, oldukça doğru.
gastropner

Kravat kırma puanınızı azaltarak ters eğik çizgilerin çoğunu kaldırabilirsiniz. Ayrıca, gibi iki baytlık simgeleri ayırmaya gerek yoktur &&.
Toby Speight


5

PHP 7, satır başına 2 bayt

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

Bu noktalar ile nasıl çalışır?
L3viathan

@ L3viathan Noktaları birleşmeyi belirtir. Tek karakterlerden uzun dize oluşturmak için kullanılırlar.
user63956

Bunu biliyorum, ancak PHP sadece atanmamış değişken isimlerinden dizeler yapıyor mu, yoksa bu nasıl çalışıyor? Fiyat teklifi göremiyorum.
L3viathan

2
@ L3viathan Bu karakterler sabittir. Bir sabit tanımlanmadıysa, PHP adını değer olarak kullanır.
user63956

5

Aseto , satır başına 1 bayt, 230 bayt

Eh, yazmak eğlenceli değildi. Bir fungoid olarak Aceto'nun kontrol yapıları 2B yapısına dayanır, ancak bununla birlikte çok sayıda koşullu kaçış ( `) ile çalışabiliriz ( ). Bunlarla ilgili tek sorun, varlığından bağımsız olarak bir sonraki komutu etkilemeleridir (tüm Aceto programları karelerdir, dahilidir), bu nedenle programı bazı noktalara boş satırlar ekleyerek bazı yerlere hizalamamız gerekir.

Dize değişmezleri gerçekten kullanılamaz, ancak char değişmezleri kullanabilir (bazı yerlerde; yine onları hizalamamız gerekir).

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

Denilen 20, bu yazdırır:

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

Tüm satır sonları anlamlı olmalıdır. Çıktıya etki etmeden kaldırılabilen ve bitişik çizgiler birleştirilebilen satır kesmeleri kaldırılmalıdır.

Burada asla böyle olmaz, çünkü aşağıdan yukarıya doğru uzanır.

2 byte tasarruf edebileceğimiz en az bir yer var ( `Xa |veya ile değiştirerek #), ancak nispeten büyük bir Hilbert eğrisi ile çalışmanın maliyetinden dolayı olduğu gibi kaldım.

Ayrıca kullanımı \rveya \r\nyeni satırları kullanma gerekliliğini de göz ardı ettim, çünkü OP'nin istenmeyen bir hata olduğunu düşünüyorum. Bu gereksinimi güçlendiren bir düzenleme veya yorum varsa, bunun yerine CR yeni satırlarını kullanmak için çok fazla sorun olmadan değiştirebilirim.

Bayt sayısı, Aceto'nun kod düzenleyici kodlamasına dayanır; Latince-7, ki £tek bayt.


Yeniden Yığındaki üç dizenin […] olduğu varsayıldığında ve Bu değişiklik okuyucunun alıştırması olarak bırakılmıştır. : Lütfen eldeki görevi çözmek için gereken tüm kodu girin. Olduğu gibi, çözümünüz eksik. Ayrıca 1 puanlı çözümler için bağ kırıcı olan bayt sayısı da yok.
Dennis

@Dennis Şimdi tam çalışma kodu sağlamak için cevabı düzenledik.
L3viathan

5

Perl 5 , satır başına 2 bayt, 182 bayt

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

Çevrimiçi deneyin!

Perl'in sözdizimi çok bağışlayıcıdır, dolayısıyla ana fikri oldukça basit kılan kod ve yorumlara birçok boşluk eklenebilir. Bu kodun temel amacı, çalıştırmak istediğimiz kodu içeren bir dize oluşturmaktır eval. Perl'de, &{...}notasyona sahip bir dize veya değişken kullanarak bir işlev çağırmak mümkündür , ancak ne yazık ki, evalbu biçimde çağrılabilir değildir, ancak ad alanı evalbytesüzerinden çağırdığınız CORE::sürecedir. Bu dizgeyi oluşturmak oldukça kolaydı ve program doğrudan bu çağrıya aktarıldı. Dizeler, XOR'un bir parçası olarak newlines kullanılarak oluşturulmuştur, bunları oluşturmak için bu betiği kullandım.. Bunu geçerli kılmak için birkaç yer yorum yapmak zorunda kaldı, böylece yeni satırların kaldırılması çalışmayan bir kodla sonuçlanacaktı.

FizzBuzz rutini, Primo'nun mükemmel cevabından alınmıştır .


Perl 5 , satır başına 1 bayt, 172 bayt

Bu yüzden, (şimdi) bunun geçersiz olduğunu biliyorum , çünkü birçok yeni satır kaldırılabilir, ancak bu benim soruna orjinal yaklaşımım olduğundan eklediğim. Perl'in sözdizimini ne kadar zorlayabildiğini görmek eğlenceliydi! Geçersiz olmasına rağmen bu problemi kendi yararına kullandım.

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

Çevrimiçi deneyin!


Bu, "Tüm satır sonları anlamlı olmalı" kuralını bozmaz mı?
12Me21

@ 12Me21 evet, sadece bakıyorum. Öyleyse, birincisi kaldırılırsa kırılır, ancak bazıları gerçekten de kaldırılabilir ve bunu 2 uzunluğa getirebilirler.
Dom Hastings

@ 12Me21 Sanırım şimdi 2 için çalışan bir çözüme sahibim, bunu yapmak için zaman harcadığımdan beri 1 byte uzunluğunun golf versiyonunu ekledim! :)
Dom Hastings

5

SmileBASIC, satır başına 9 7 bayt, 159 155 154 152 bayt

Bu gerçekten eğlenceli bir mücadele oldu. Ne yazık ki, gereksiz satır sonları karşı kural birkaç sorun, (gerçi neyse ki burada en büyük satır uzunluğunu etkilemez.) Ben gibi satırlar arasındaki yorum eklemek zorunda neden olur A%=I/3ve A=A%*3çünkü, A%=I/3A=A%*3SB doğru ayrıştırılır. Bazı yorumları bırakmak için bir numara kullanabildim, çünkü Aonunla değiştirmek Eo satırı geçersiz kılıyor ( ENot gösterimi ile yazılan sayılarla bir ilgisi var , sanırım. 3EBir sayı ve değişken adı yerine geçersiz bir sayı olarak kabul edilir.)

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

Buradaki en büyük sınırlama girdi almaktır. INPUT xizin verilen en basit yoldur, alternatif ise bir giriş değerine sahip DEF F xancak yine de 7 karakterlik bir fonksiyon tanımlamaktır . Koşullu bir açıklama yapmak da zordur; Bundan daha kısa bir şey düşünemiyorum WHILE x.


1
Eğer A%=I/3A=A%*3sözdizimsel olarak geçerli ama mantıksal olarak kırılmış, sen açıklama kömürü gerekmez.
Nick T,

Doğru olarak A%=I/3ve olarak ayrıştırıldı A=A%*3, bu nedenle yorum gerekiyor.
12Me21

3

JavaScript (ES6), satır başına 3 bayt

Aşağıdaki kodu verdiğimiz nesneye toperişmek için global değişkeni kullanır :windoweval

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

topKorumalı bir Yığın Parçacığından erişilemez olduğu için konsolu çalıştırmanız gerekecektir .


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 #, satır başına 9 bayt, 248 242 230 bayt

C # satır çizgilerini önemsemediği için, kurallara uymak için neredeyse her satırın (ondan sonra Ørjan Johansen) sonunda bir yorum yapması gerekir. Bu program n'yi bir komut satırı argümanı olarak bekler . İşte mümkün olduğunca çok sayıda silinebilir newlines ile:

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

Ancak en uzun satır 9 byte olduğundan diğer satırlar da bu kadar uzun olabilir ve bazı baytları tıraş eder:

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

Birleştirme işlemini "aralarında boşluk bırakmadan" olarak yorumladım, bu nedenle ve gibi birbirine karışacak belirteçler arasında ihtiyacınız yok . //staticvoid
Ørjan Johansen

@ ØrjanJohansen Teşekkürler! 6 bayt kurtarıldı
Arthur Rump,

Sanırım yeniden düzenleyerek daha fazla byte kaydedebilirsiniz var s="";if// (i%3==0// )s+=// "Apple"// ;if(i%5//.
Ørjan Johansen

Ve Ailk çizgiden ikinci çizgiye geçmek için benzer bir fırsat var .
Ørjan Johansen

Ayrıca yeni bir satırdaki ikinci alıntı ile "\ n" 'yi @ ""' ye değiştirerek 3 bayt kaydetti, bu yeni satırı da gerekli kıldı.
Arthur Rump,

2

Python 2, 5 bayt / satır, 93 bayt

Max6 standardı zaten eskidir.

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

Çevrimiçi deneyin!

Python 2 ve 3, 5 bayt / satır, 100 bayt

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

Çevrimiçi deneyin!


2

JavaScript, en fazla 6 bayt / satır, 528 bayt

Fikir buradan sökülmüş .

Kod buradan sökülmüş .

Anders Kaseorg'a teşekkürler g=eval, her satıra bir bayt kazandırdı.

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'

a=""+\n"f"+\n"o"+ ...ve biten eval(\na)biraz daha kısa
Value Ink

Kurallar biraz değişti (ApplePie, giriş yap), ancak planın hala geçerli olmalı.
Nick T,

Kural değişikliği @ ValueInk'in önerisini geçersiz kılıyor, ancak yine de f=evalve ile sonlandırabilirsiniz f(a).
Anders Kaseorg

@AndersKaseorg teşekkür ederim :) bunu düşünmedim
Stephen

1
İlk satırdaki dizeye 2 karakter koyarak bir bayt kaydedebilirsiniz.
12Me21

2

PHP, 4 Bayt / satır

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

Çevrimiçi deneyin!


Tüm satır sonları anlamlı olmalıdır. Çıktıya etki etmeden kaldırılabilen ve bitişik çizgiler birleştirilebilen satır kesmeleri kaldırılmalıdır.
Julian Wolf

@JulianWolf Bunu değiştirdim
Jörg Hülsermann

2

APL (Dyalog) , satır başına 5 bayt

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

Çevrimiçi deneyin!


2

Retina , 4 bayt / satır

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

Çevrimiçi deneyin!


2

R , satır başına 10 bayt, 800 bayt

"Anlamlı satır vuruşları" kuralı bunu zorlaştırdı. Şu anda bu sadece fizzbuzz kodunu bir dizgeye çeviriyor ve ardından çalıştırıyor.

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)

Çevrimiçi deneyin!

İşte (uyarlanmıştır birleştirilmiş applepie kodudur MickyT en golf burada ).

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

Ve ayrıştırma kodunun ungolfed versiyonu:

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

Burada toStringsembollerin listesini atek bir dizgede birleştirmek için kullanıyorum . Bununla birlikte, varsayılan davranış, her bir sembolü ayırmaktır ,, bu nedenle gsubnull'lerle değiştirmek için çağırırız . Sonra onu geçmek parseve evalkirli işler yapmak için.

Bu fizzbuzz bu dize ayrıştırma yöntemi ve sadece düz uygular kadar kullanmayan bir yaklaşım söz konusu olabilir, ama kullanmadan geliyor bana forya whileya belirleyici bir functiongeçirilmesi gerekir cari yaklaşımından daha uzun çizgiler.


2

Ruby, 10 5 bayt / satır, 354 214 bayt

@NieDzejkob tarafından elde edilen ham puandan -140 bayt.

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

Nasıl çalışır

Ruby, aynı ifadedeki dizge değişmezleri dizilerini (gibi tek karakter değişmezleri hariç) otomatik olarak birleştirir ?a. Bunun anlamı x = "a" 'b' "c" %q{d}eşdeğerdir x = "abcd". Bunu FizzBuzz benzeri kodu bölmek için çok daha küçük dizgelere bölmek için kullanıyoruz eval, çünkü +programı newlines kuralına göre geçersiz kılar, ancak \yeni satırlar çıkarıldığında sözdizimi hatalarına neden olur!


Benzer bir şey göndermek
üzereydim

Kurallar biraz değişti ('ApplePie, bir giriş yap), ancak planın hala geçerli olmalı.
Nick T,

Her satıra dizeye iki karakter ekleyerek çok sayıda bayt kaydedebilirsiniz.
NieDzejkob

Buradaki birincil puanlama mekanizması @NieDzejkob, satır başına bayt, yani satır uzunluğunu azaltmak için toplam bayttan ödün vermenin daha iyi olduğu anlamına gelir.
Value Ink,

@NieDzejkob nvm Şimdi ne demek istediğinizi anlıyorum, çünkü ilk evalsatır diğerlerinden daha uzun, değil mi?
Value Ink,

1

Julia 0.6 , satır başına 5 bayt, toplam 168 bayt

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)

Çevrimiçi deneyin!

Bu print, kaçınılmaz bir şekilde (açık), satır başına 5 bayta getirir.

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

*dize birleştirme işleci, bu nedenle a*p*"\n""ApplePie \ n" oluşturur. |>işlev zincirleme (/ piping) operatörüdür, böylece seçilen dize argüman olarak gönderilir print. sinÇünkü bu sadece orada, kullanılmadığı printihtiyaçlar (kullanarak onun peşinden önemli boşluk olması bir dizide olmak #o 6'ya satır başına maksimum bayt sayısını getirecektir sonra hile).


Çıktıyı bir dizi olarak izin vermek yeterliyse, satır başına maksimum 4 bayt ile yapılabilir:

Julia 0.6 , satır başına 4 bayt, toplam 152 bayt

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

Çevrimiçi deneyin!

N'yi alan ve beklenen çıkışı içeren bir dizi döndüren işlev. Buradaki maksimum hat uzunluğu, n->Julia tarafından sınırlandırılmıştır - Julia, bir lambda başlangıcı olarak düzgün bir şekilde ayrıştırmak için tek bir hatta ihtiyaç duyar.


1

Pascal (FPC) -Sew , satır başına 6 bayt, 348 320 bayt

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.

Çevrimiçi deneyin!

FPC'yi satır başına 6 bayt almak için kullanır; onsuz, sonuç çok daha kötü olurdu. Bu, mümkün olan en küçük çizgi genişliğidir, çünkü sonradan writeya ;da ((ya da gereksiz beyaz boşluklar) olması gerekir , bu yüzden bunu önlemek için özel bir yorum eklenir. Bu cevabı etkileyen FPC'nin özellikleri şunlardır:

  1. // - tek satırlık yorumlar başlatılıyor.
  2. Formdaki blok yorumları {$<something>...}derleyici direktifleridir. Yönerge mevcut değilse, FPC bir uyarı verecektir (ve {$ ...}aynı zamanda). Bu program {ve $silindiğinde uyarı verecek bir yeni satır ile ayrılır.
  3. -Sew- Derleyici da durur uyarıdan sonra, böylece {ve $birleştirilen durdurma derleme.


1

LOLCODE , satır başına 18 8 bayt, toplam 303 bayt

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

Çevrimiçi deneyin!

Ørjan Johansen sayesinde hat devam karakterini kullanarak satır başına -10 bayt !


Bunu… satırındaki devam karakteri ile 8'e kadar alabilirsiniz. Çevrimiçi deneyin!
Ørjan Johansen

Her gün bu eserler hakkında yeni bir şeyler öğreniyorum. Teşekkürler, Oerjan!
JosiahRyanW

0

Python 2 , 5 bayt / satır

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

Çevrimiçi deneyin!


Dikkatli! ⏎ ile 'z\"'aynı anlama gelir , bu nedenle gereksiz newline kuralı, dizenin içinde bir devam hattı başlatmanıza izin verilmeyeceği anlamına gelir . 'z\"'"
Anders Kaseorg

@AndersKaseorg r'...'şimdi yaptı
Martmists

Bu atar SyntaxError.
Outgolfer Erik,

TIO bir numarayı erken durdurur. Ayrıca, kurallar kullanılarak değiştirildi FizzBuzzkullanmayaApplePie .
Ørjan Johansen

0

JavaScript (ECMAScript6), satır başına 2 bayt

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


Uzun açıklama

Satırları kısaltmamızın yolu, kodu bir dizgeye dönüştürmek ve satır sonlarından kaçmaktır; bu, satır başına 2 baytlık bir sınır getirecektir.

Öyle alert(1)olur

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

Ancak şimdi kodunuz bir dizedir, bu nedenle dizeyi kod olarak yürütmemiz gerekir. Dize kod olarak yürütmenin en az 4 yolunu biliyorum:

  1. eval (kod) . Aramak için en az 5 bayt sürereval(
  2. setTimeout (kod, zaman aşımı) . Fonksiyonu asenkronize olarak çalıştırır, ancak isteğe bağlı olarak bir dizgiyi geçirirseniz, içten eval'ü çağırır.
  3. DOM'den faydalanabilir ve kodunuzu bir onclick=""özniteliğin içine koyabilirsiniz , ancak öğe oluşturmayı kısmen kısaltmayı başaramadım.
  4. Çağırmak Function yapıcısını new Function () , kodunuzu daha sonra çağırabileceğiniz adsız bir işleve ayrıştırır (bunu kullandım).

Tüm yerel işlevler, pencere nesnesinin içinde yaşar ve javascript'te, nokta gösterimini kullanarak nesne özelliklerine erişebilir, böylece eval()olur window.eval()ya da ayraç gösterimini kullanarak özelliklere erişebilirsiniz window['eval'](). Daha evalönce açıklanan yöntemi kullanarak çoklu çizgileri kırmak için bundan yararlanabilirsiniz . Ama yine de pencereyi yazmak zorundasınız , bir püf noktası, bir çerçevenin içinde değilseniz üst değişkenin de pencere olduğu, yani window.eval'in top.eval olacağı (3 byte az).

w=top
w['eval']

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

Bu, kodu en az 3 bayt yapacaktır. Kod 2 bayt yapmak için yapıcıyı kullandım new Function(/*string*/);, ancak yazmak zorunda kalmadan erişebilmek için yaratıcı olmam gerekiyordu.

İlk olarak, İşlev yapıcısı, yeni anahtar kelimeyi çıkartan bir işlev olarak çağırmanıza izin verir, bu, 4 baytı azaltır ancak başka bir nedenle de önemlidir. Yapıcıyı işlev olarak çağırmak yine de dönmemize izin veren bir örnek döndürür new Function(code).Function(code) . Bir diğer önemli husus, İşlev yapıcısının callherhangi bir işlevi çağırmanıza izin veren ancak bu referansı geçersiz kılan bir yönteme sahip olması ve İşlev yapıcısının kendisinde onun gibi bir yöntem olarak çağırabileceğiniz bir işlev olmasıdır Function.call(null, code).

Tüm yerel işlevler, İşlev yapıcısının örnekleridir ve javascript'teki tüm nesnelerin yapıcı özelliği vardır. Böylece, herhangi bir yerel işlevdeki İşlev yapıcısına erişebilir alert.constructorve call yöntemini kullanarak yapıcıyı işlev olarak çalıştırabiliriz. Şimdi biz alert.constructor.call (null, code) bir fonksiyon döndürür.

önceki teknolojilerin birleştirilmesiyle onu dönüştürebiliriz alert['constructor']['call'](null, code)

Şimdi kısa bir adlandırılmış işlev veya yöntem bulmamız gerekiyor, bu yüzden String yapıcısının içindeki big () yöntemini seçiyorum . Böylece doğrudan boş bir dizeden erişebiliyorum"".big

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

Sonra her şeyi 2 baytta kırdım.

Kısa er açıklama (TLDR)

Yeni Function (code) yapıcısına eval (code) yerine dizeyi ayrıştırmak için erişiyorum . Bu yapıcı, anyFunction işlevini kullanarak her yerel işlevde kullanılabilir. yapıcı , gibi alert.constructor===Function. String.prototype.big içinde bir işlev / yöntem kullanıyorum, String.prototype.big.constructor.call(null, /*string*/) ancak doğrudan bir dizgiden birebir erişerek onu parantez notasyonuna"".big çevirdim . kullanarak kırabilmeniz için .""['big']['constructor']['call'](0, CODE)\


1
Ne yazık ki, bunun geçersiz olduğunu düşünüyorum, çünkü örneğin herhangi bir satır sonu 've ]kaldırılabilir ve program hala başarılı bir şekilde çalışacaktır.
darrylyeo

2 genişliğinde verilen herhangi bir şekilde düşünemiyorum. Ama neredeyse aynı yaklaşımlara sahip olduğumuz için , belki de açıklamanızın uyarlanmış bir versiyonunu cevabımı ekleyebilir, bu yüzden hepsi kaybolmaz.
darrylyeo

0

Pip , satır başına 3 bayt, toplam 72 bayt

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

Çevrimiçi deneyin!

Pip boşlukla ilgili son derece esnek, bu nedenle uygulanabilir görünen tek strateji bir ip oluşturmak, onu yeni çizgilerin rahatsız edilmemesini gerektirecek şekilde değiştirmek ve değerlendirmektir.

Diğer her karakterin yeni bir satır olduğu bir dize yaratır ve diğer karakterlerini UW(unweave) ve unary @(first element al) kullanarak alırız :

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

Bunun sonucu, burada@UW FizzBuzz çözümünden uyarlanan ApplePie kodumuz olmalıdır. . Dizideki herhangi bir yeni satır silinirse, bu tam kodla sonuçlanmayacak ve sözdizimi hatası ya da yanlış çıktı verilecektir.

Dize dışında hala iki yeni satır var. Bunları zorunlu kıldık Y; burada no-op olarak işlev gören (yank) operatörünü, Pip ayrıştırma işlemlerinin büyük harfli harfleri ile birlikte kullanmasını sağladık:

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

Bu yüzden eğer bu yeni satırlar silinirse, program farklı şekilde ayrıştırılır ve olması gerekeni yapmaz.


0

Java 8, satır başına 7 bayt, 171 bayt

Bir boş lambda alarak bir int. Bunun yeni hatlarla ilgili şartlara uyduğundan şüpheleniyorum, ancak kanıtlayamıyorum ve kaba kuvvetle onaylamak bilgisayarımda bir ay kadar sürebilir. O zaman o gider.

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

Çevrimiçi Deneyin

Satır yorumları nedeniyle oldukça sıkıcı. Buradaki tek ilginç şey System, satır başına 8 bayt altında standart çıktı almak için gerekli gibi görünen boş bir referans kullanılmasıdır . Ayrıca şunu unutmayın:print yöntem çağrısının darboğaz olduğunu unutmayın.

Yorumsuz 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"
        );
}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.