लंबी लाइनों के खिलाफ स्टैंड लें

Question

हाल ही में, किसी ने पायथन की डिफ़ॉल्ट लाइन की लंबाई के लिए और अधिक कठोर सीमाएँ प्रस्तावित कीं:

स्पष्ट रूप से, किसी भी कार्यक्रम को कभी भी प्रति पंक्ति 80 से अधिक वर्णों का उपयोग नहीं करना चाहिए, पूरे कारणों से। सबसे पहले और सबसे महत्वपूर्ण, पठनीयता और स्थिरता के लिए, एक ठोस मानक होना जरूरी है, इसलिए हम अपने पाठ संपादकों की चौड़ाई को उचित रूप से समायोजित कर सकते हैं। एक माध्यमिक लाभ के रूप में, कोड को आसानी से मीडिया पर स्थानांतरित किया जा सकता है जिसमें प्रतिबंध हो सकते हैं, और जहां लाइन-ब्रेक जोड़ना विचलित हो सकता है, जैसे मीटिंग में समीक्षा के लिए प्रिंट पेज, या पंच कार्ड।

लेकिन क्या 80 अक्षर बहुत अधिक है? कुछ का सुझाव है कि 79, या 75 के रूप में भी कम, लाइन वर्णों के लिए समर्पित कुछ स्तंभों के साथ कोड को फिट करने के लिए 80 वर्ण चौड़ा टर्मिनल के लिए अनुमति देता है। स्पष्ट रूप से, अंततः, कम बेहतर है, क्योंकि निचली सीमाएं कोड को सुधार के बिना अधिक परिस्थितियों में उपयोग करने की अनुमति देती हैं।

पेश है अधिकतम 6 मानक

आपका लक्ष्य किसी भी पंक्ति में सबसे कम वर्णों के साथ एक FizzBuzz संस्करण लिखकर अपनी पसंदीदा भाषा द्वारा आवश्यक न्यूनतम पंक्ति लंबाई को खोजना और प्रदर्शित करना है।

इनपुट

किसी भी इच्छित विधि के माध्यम से एक पूर्णांक, एन ।

उत्पादन

1 से n तक की संख्याओं को प्रिंट करें , ( n n 1, n ℤ by) को अलग करके लाइन ब्रेक द्वारा, सिवाय:

• 3 प्रिंट "Apple" के गुणकों के लिए
• 5 प्रिंट "पाई" के गुणकों के लिए
• 3 और 5 दोनों के गुणकों के लिए "ApplePie" प्रिंट करें

स्कोरिंग

बाइट्स में अधिकतम लाइन की लंबाई, लाइन ब्रेक (सीआर, सीआरएलएफ, एलएफ, या अन्य सिस्टम मानक ब्रेक, निर्दिष्ट, वांछित के रूप में), और बाइट्स के रूप में बाइट्स में कुल कोड लंबाई शामिल नहीं है।

नियम

सभी लाइन ब्रेक सार्थक होना चाहिए। लाइन ब्रेक जो हटाए जा सकते हैं और आसन्न लाइनों को सीधे आउटपुट पर प्रभाव के बिना समवर्ती किया जाना चाहिए, हटाया जाना चाहिए।

Comments

न्यूलाइन प्रतिबंध पर, यदि किसी विशिष्ट समूह को हटाने के कारण यह कार्य करता है, लेकिन किसी एक एकल पंक्ति को हटाने से यह विफल हो जाता है, तो क्या नई सूचियों को हटाया जाना चाहिए? वे वाक्यात्मक रूप से महत्वपूर्ण हैं बस यह है कि उनमें से कुछ को हटाने से उनका महत्व समाप्त हो जाता है।

— गेहूं जादूगर

मुझे यकीन नहीं है कि मैं "सार्थक" newlines नियम के बारे में कैसा महसूस करता हूं। जब यह कानूनी वाक्यविन्यास की बात आती है, तो प्रोग्रामिंग भाषाओं की एक विस्तृत संख्या में नई कहानियों की परवाह नहीं होती है और आपको पूरे कार्यक्रम को एक पंक्ति में लिखने देगा - बस यहां अधिकांश कोड-गोल्फ समाधानों पर एक नज़र डालें :-P

— nderscore

इसे मानक के बजाय एप्पल पाई में क्यों बदला

— रोहन झुनझुनवाला

@RohanJhunjhunwala बिलियन FizzBuzz कमांड का उपयोग करने से रोकने के लिए।

— अर्जन जोहान्सन

+1 यह वास्तव में एक कोड गोल्फ चुनौती के लिए एक बहुत अच्छा विचार है! प्रति पंक्ति वर्णों की छोटी संख्या अव्यावहारिक प्रतीत होती है, हालांकि it मैं अभी भी इसे पसंद करता हूं

— जॉर्ज विलकॉक्स

Answer 1

> <> , प्रति पंक्ति 1 बाइट, 243 161 135 बाइट्स

-26 राजा को धन्यवाद बाइट्स!

2D भाषाएँ FTW! हालांकि 2D संरचना के बजाय गोटो निर्देशों का उपयोग करते हुए लूप और शाखाएं लिखना मजेदार नहीं है।

v
l
:
:
3
%
:
&
0
4
7
*
&
?
.
~
~
"
e
l
p
p
A
"
o
o
o
o
o
$
5
%
:
&
0
a
5
*
&
?
.
~
~
"
e
i
P
"
o
o
o
*
0
@
?
n
?
~
l
{
:
}
=
?
;
a
o
1

इसे ऑनलाइन आज़माएं! , या मछली खेल के मैदान में इसे देखो !

मछली कोड के साथ नीचे की ओर तैरती है, जो संचयक को विभाजित करने के आधार पर चीजों को छोड़ने के लिए सशर्त गोटो का उपयोग करती है।

मेरा मानना ​​है कि यह कल्पना को पूरा करता है: जो भी नई लाइनें हटा दी जाती हैं, मछली हमेशा प्रारंभिक v(एकमात्र दिशा-बदलते निर्देश) को हिट करती है , इसलिए मछली हमेशा पहले कॉलम में नीचे की ओर तैरती है। इस प्रकार एक नई लाइन को हटाने से मछली के मार्ग से अगले चरित्र को हटाने का प्रभाव पड़ता है, और मुझे नहीं लगता कि आप आउटपुट को बदले बिना किसी भी वर्ण को हटा सकते हैं।

Comments

कितने बाइट्स है?

— L3viathan

@ L3viathan, यह 243 बाइट्स है। (मैं इसे संपादित करूँगा।)

— एक पेड़

@ L3viathan: मैंने इसे थोड़ा पुनर्व्यवस्थित किया और अब यह 161 बाइट्स है!

— एक पेड़ नहीं

:( मुझे नहीं लगता कि मैं अपना जवाब इतना नीचे दे सकता हूं ...

— L3viathan

135 बाइट्स । और यहाँ संदर्भ के लिए क्षैतिज संस्करण है

— जो किंग

Answer 2

हास्केल , 3 बाइट्स / लाइन, 494 471 470 463 453 450 461 बाइट्स

संपादित करें:

• -26 बाइट्स: कुछ निरर्थक लाइनब्रीक और उनके संबंधित टिप्पणी मार्करों को हटा दिया -1+xगया और बदल दिया गया x-1।
• +3 बाइट्स: उफ़, --बाद में अतिरिक्त लाइन की आवश्यकता है x-।
• -1 बाइट: इसके बजाय fउपयोग c 47:[]में [c 47&0]।
• -7 बाइट्स: न्यूलाइन हैंडलिंग को मूव करें w।
• -10 बाइट्स: इनलाइन a="Apple"और p="Pie"में #और 15 मामले के लिए एक डमी प्रत्यावर्तन का उपयोग करें।
• -3 बाइट्स: इनलाइन wमें f। के --बीच निरर्थक निकालें xऔर 15।
• +11 बाइट्स: उफ़ फिर से! मेरे स्ट्रिंग गैप सिद्धांत में छेद था। %फ़ंक्शन शुरू करके निश्चित किया गया । अंत में यह सुनिश्चित करने के लिए कुछ स्वचालित परीक्षण किए गए कि कोई और आश्चर्य की बात नहीं है।

fएक लेता है Intऔर एक रिटर्न देता है String।

{;f
n=
--
[--
1..
--
n--
]--
>>=
\
--
x->
--
gcd
x
15#
--
x++
--
c
47:
--
[--
]--
;1#
--
x=
--
n!!
--
(x-
--
1--
)--
;3#
--
_=
--
"A\
\p\
\p\
\l\
\e\
\"&
--
0--
;5#
--
_=
--
"P\
\i\
\e\
\"&
--
0--
;--
15#
--
_=
--
3#
--
0++
--
5#
--
0--
;n=
--
d++
--
[--
s++
--
t|
--
s<-
--
n--
,--
t<-
--
[c
9]:
--
d--
]--
;d=
--
(:
--
[--
]--
)--
<$>
--
[c
8..
--
c
0--
]--
;c
x=
--
[--
"9\
\"%
--
0--
,--
"8\
\"%
--
0..
--
]!!
--
x--
;--
[--
a]%
--
_=
--
a--
;x&
--
y=
--
x}

इसे ऑनलाइन आज़माएं!

टेस्ट स्रोत प्रतिबंध!(लाइन 70 को परीक्षण से बाहर रखा गया है क्योंकि इसकी नई लाइन को हटाने से आउटपुट के बिना एक अनंत लूप पैदा होता है।)

सबसे महत्वपूर्ण निचोड़ चाल के साथ संस्करण हटाया गया:

{;f n=[1..n]>>= \x->gcd x 15#x++c 47:[]
;1#x=n!!(x-1)
;3#_="Apple"
;5#_="Pie"
;15#_=3#0++5#0
;n=d++[s++t|s<-n,t<-[c 9]:d]
;d=(:[])<$>[c 8..c 0]
;c x=["9"%0,"8"%0..]!!x
;[a]%_=a
;x&y=x}

यह काम किस प्रकार करता है

• यह कोड हास्केल के अधिक शायद ही कभी इस्तेमाल किए गए इंडेंटेशन असंवेदनशील मोड में लिखा गया है, जिसके साथ एक पूरे कार्यक्रम को घेरकर ट्रिगर किया गया है {}। चूंकि मैं वास्तव में एक पूरे कार्यक्रम के बजाय एक फ़ंक्शन को परिभाषित कर रहा हूं, इसलिए मुझे यकीन नहीं है कि बाइट्स कैसे गिनें; मैंने रक्षात्मक रूप से एस और एक अतिरिक्त घोषणा विभाजक दोनों को गिनने के लिए चुना है (उत्तरार्द्ध आमतौर पर सामान्य मास्क मोड में एक नई रूपरेखा है।){};
• न्यूलाइन्स को "सार्थक" बनाने के लिए मुख्य ट्रिक है --लाइन कमेंट्स, जो अगली न्यूलाइन को नॉन-रिमूवेबल बनाते हैं और ए भी केस की पिछली न्यूलाइन को जब पिछली लाइन एक ऑपरेटर कैरेक्टर में खत्म होती है (जो खुद एक लाइन कमेंट का हिस्सा नहीं है) ।
• दूसरी चाल "स्ट्रिंग अंतराल" है, जो बीच में व्हाट्सएप का एक क्रम है \ स्ट्रिंग लिटरल्स में बैकस्लैश के व्हाट्सएप , संभव इंडेंटेशन के साथ लाइन निरंतरता के लिए इंडेंट किया गया। सीमांकित स्ट्रिंग से सीमांकक के साथ एक स्ट्रिंग अंतर को हटा दिया जाता है।
  • यदि स्ट्रिंग गैप की नई रेखा को हटा दिया जाता है, तो यह स्ट्रिंग में एक अतिरिक्त बैकस्लैश बन जाता है। के लिए "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।
• #15 के साथ Int xहै कि एक अतिरिक्त तर्क दिया अपने एक ApplePie रूप में धर्मान्तरित ।gcdx

Answer 3

हास्केल , 7 बाइट्स / लाइन, 339 बाइट्स

सार्थक होने के लिए लाइन ब्रेक की आवश्यकता हास्केल में यह एक चुनौती है। लाइन ब्रेक सम्मिलित करने के लगभग कोई तरीके नहीं हैं जिन्हें हटाया नहीं जा सकता है, इसलिए सब कुछ वैध रूप से छोटे बयानों के साथ किया जाना है।

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

इसे ऑनलाइन आज़माएं!

Answer 4

जेली , 3 2 बाइट्स / लाइन, 106 80 56 बाइट्स

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

स्ट्रिंग शाब्दिक की पंक्तियों और स्तंभों को स्थानांतरित कर दिया जाता है, इसलिए नए सिरे को हटाने से उनका क्रम गड़बड़ हो जाता है।

शेष लाइनें अलग-अलग लिंक / फ़ंक्शन हैं और फ़ंक्शन कॉल ( ¢) हैं, इसलिए उन्हें केवल तभी सुधारा जा सकता है यदि फ़ंक्शन कॉल भी समाप्त हो जाए।

इसे ऑनलाइन आज़माएं!

Answer 5

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 बाइट्स होगी, जिसे मैं प्राप्त करने में सक्षम नहीं था।

Comments

लेकिन गोल्फ संस्करण में सबसे लंबी लाइन 10 बाइट्स हैIf A and B

— 21

@jmarkmurphy TI-BASIC एक टोकन भाषा है, और अधिकांश टोकन एक एकल बाइट द्वारा दर्शाए जाते हैं। मैंने उल्लेख किया कि समाधान के अपने विवरण में। आप इस विकी के बारे में अधिक पढ़ सकते हैं ।

— kamoroso94

लेकिन इसका आधार यह था कि संपादकों को प्रति पंक्ति वर्णों की न्यूनतम संख्या की अनुमति देनी चाहिए। मुझे संदेह है कि आप एक संपादक के साथ टोकन टाइप कर रहे हैं। और मुझे नहीं लगता कि अन्य भाषाओं में जो विशुद्ध रूप से व्याख्या नहीं की गई हैं वे एक संकलित वस्तु या टोकन बाइट गणना का उपयोग कर रही हैं।

— jmarkmurphy

@jmarkmurphy वास्तव में आप संपादक में टोकन टाइप करते हैं। Ansटोकन, 1 बाइट है, जबकि लगातार तीन पात्रों Ans1, 2 रहे हैं, और 2 5. के लिए कुल क्रमश बाइट्स यह एक ASCII स्ट्रिंग नहीं है, यह सचमुच टोकन है जब आप कैलकुलेटर पर लिखें।

— kamoroso94

मेटा पर पहले से ही इस पर कुछ सहमति है ।

— kamoroso94

Answer 6

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

इसे ऑनलाइन आज़माएं!

Comments

@ अर्जन जोहान्सन अह, काफी सही।

— गैस्ट्रोपनर

आप अपने टाई-ब्रेक स्कोर को कम करके, बहुत सारे बैकस्लैश निकाल सकते हैं। इसके अलावा, दो-बाइट टोकन को अलग करने की कोई आवश्यकता नहीं है &&।

— टोबी स्पाइट

Answer 7

अजगर ३ , 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)

इसे ऑनलाइन आज़माएं!

Comments

तुम्हें पता है कि तुम अंदर parens newlines के लिए वापस स्लैश की जरूरत नहीं है?

— विनाशकारी नींबू

ओह, रुको मैंने उपयोगी न्यूलाइंस नियम नहीं पढ़ा है

— विनाशकारी नींबू

@NICKT: नियमों में बदलाव किया गया।

— एंडर्स केसरग

Answer 8

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

Comments

यह डॉट्स के साथ कैसे काम करता है?

— L3viathan

@ L3viathan डॉट्स कॉन्सेप्टन को दर्शाता है। वे एकल पात्रों से लंबे तार बनाने के लिए उपयोग किए जाते हैं।

— user63956

मुझे पता है कि, लेकिन क्या PHP सिर्फ अनरजिस्टर्ड वैरिएबल नामों से स्ट्रिंग्स बनाता है, या यह कैसे काम करता है? मैं कोई उद्धरण नहीं देख रहा हूँ।

— L3viathan

@ L3viathan वे पात्र निरंतर हैं। यदि किसी स्थिरांक को परिभाषित नहीं किया गया है, तो PHP मान के रूप में अपने नाम का उपयोग करता है।

— user63956

Answer 9

Aceto, 1 byte per line, 230 bytes

खैर, यह लिखने में मज़ा नहीं आया। एक कवक के रूप में, एकेटो की नियंत्रण संरचनाएं इसकी 2 डी प्रकृति पर बहुत अधिक निर्भर करती हैं, लेकिन हम इसके आसपास काम कर सकते हैं, बहुत सारे, बहुत सारे सशर्त पलायन (` )। उन लोगों के साथ एकमात्र समस्या यह है कि वे अगले आदेश को प्रभावित करते हैं, चाहे इसकी उपस्थिति की परवाह किए बिना (सभी एसीटो प्रोग्राम आंतरिक रूप से हैं), यही कारण है कि हमें कुछ स्थानों पर खाली लाइनों को सम्मिलित करके कुछ स्थानों पर कार्यक्रम को संरेखित करने की आवश्यकता है।

स्ट्रिंग शाब्दिक का उपयोग वास्तव में नहीं किया जा सकता है, लेकिन चार शाब्दिक (कुछ स्थानों पर फिर से, हमें उन्हें संरेखित करने की आवश्यकता है)।

&
p
$
L
Q
`
L
p
`
L
d
`
L
Q
`
L
Q
`
L
x
`

L
M
!
%
5
d
$
L
Q
`
L
Q
`
L
p
`
L
d
`
L
Q
`
L
x
`
L
M
!
%
3
d
$
L
p
`
L
d
`
L
x
`

L
M
!
%
*
5
3
d
[
X
`

n
=
0
l
)
@
(
z
i
r
{
J
s
]
d
s
}
d
[
~
£
A
'
d
p
'

l
'

e
'

{
~
£
P
'

i
'
e
'

20इस प्रिंट के साथ कॉल किया गया :

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

सभी लाइन ब्रेक सार्थक होना चाहिए। लाइन विखंडन, जो आउटपुट पर प्रभाव के बिना समीपवर्ती रेखाओं को हटाया जा सकता है, हटाया जाना चाहिए।

यहाँ ऐसा कभी नहीं होता है क्योंकि यह नीचे से ऊपर तक चलता है।

कम से कम एक जगह है जहां हम 2 बाइट ( या के `Xसाथ प्रतिस्थापित करके) बचा सकते हैं|# ) , लेकिन मैंने इसे रखा क्योंकि यह रनटाइम लागत अपेक्षाकृत बड़े हिल्बर्ट वक्र के माध्यम से चलने से जुड़ा है।

मैं भी प्रयोग करने के लिए अंतर्निहित आवश्यकता पर ध्यान नहीं दिया \rया\r\n न्यूलाइन्स के क्योंकि मुझे लगता है कि यह ओपी द्वारा एक अनजाने में हुई गलती है। यदि इस आवश्यकता को पुष्ट करने वाला कोई संपादन या कोई टिप्पणी है, तो मैं इसे बिना किसी परेशानी के बदल सकता हूं ताकि CR newlines का उपयोग कर सकें।

बाईटेकाउंट एसिटो के कोडगोल्फिंग एन्कोडिंग पर आधारित है; लैटिन -7, जिसमें £एक एकल बाइट है।

Comments

पुन स्टैक पर तीन तार मान लिया जाये कि [...] और यह प्रतिस्थापन पाठक के लिए एक व्यायाम के रूप में छोड़ दिया जाता है। : कृपया कार्य को हल करने के लिए आवश्यक पूर्ण कोड प्रदान करें। जैसा है, आपका समाधान अधूरा है। यह भी बाइट गिनती है, जो 1. के स्कोर के साथ समाधान के लिए टाई ब्रेकर है का अभाव है

— डेनिस

@ डेनिस मैंने अब पूर्ण कार्य कोड प्रदान करने के लिए उत्तर संपादित किया है।

— L3viathan

Answer 10

पर्ल 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#
))

इसे ऑनलाइन आज़माएं!

पर्ल का वाक्यविन्यास बहुत क्षमाशील है, इसलिए कोड और टिप्पणियों में बहुत सारे अंतराल जोड़े जा सकते हैं, जो मूल विचार को काफी सरल बनाता है। इस कोड के साथ मुख्य उद्देश्य एक स्ट्रिंग का निर्माण करना है जिसमें वह कोड है जिसे हम चलाना चाहते हैं, और evalयह। पर्ल में, &{...}संकेतन के साथ एक स्ट्रिंग या चर का उपयोग करके फ़ंक्शन को कॉल करना संभव है, दुर्भाग्य से, हालांकि, evalइस रूप में evalbytesकॉल करने योग्य नहीं है, लेकिन जब तक आप इसे CORE::नाम स्थान के माध्यम से कॉल करते हैं । उस स्ट्रिंग का निर्माण काफी सीधा था और इस कॉल के लिए प्रोग्राम को सीधे पास किया जाता है। इन्हें बनाने के लिए तार XOR के हिस्से के रूप में नईलाइन्स का उपयोग करते हुए बनाए गए हैं मैंने इस स्क्रिप्ट का उपयोग किया है। इसे वैध बनाए रखने के लिए, कुछ स्थानों पर टिप्पणियाँ रखी गई हैं, ताकि नई कड़ियों को हटाने से गैर-कामकाजी कोड हो।

FizzBuzz दिनचर्या को प्राइमो के उत्कृष्ट उत्तर से लिया गया था ।

---

पर्ल 5 , 1 बाइट प्रति पंक्ति, 172 बाइट्स

इसलिए, मैं (अब) जानता हूं कि यह अमान्य है , क्योंकि नई सूची का एक गुच्छा हटाया जा सकता है, लेकिन चूंकि यह समस्या का मूल दृष्टिकोण था, इसलिए मैं इसे जोड़ रहा हूं। यह मजेदार था कि आप पर्ल के सिंटैक्स को कितनी दूर धकेल सकते हैं! मैंने अपनी योग्यता के आधार पर इस समस्या का आनंद लिया, भले ही यह अमान्य है।

&
{
(
I
.
'
X
0
o
k
h
~
'
.
(
p
|
Y
)
)
^
'
E
O
0
|
f
s
o
'
}
(
'
x
d
!
K
z
o
Q
U
9
$
Z
o
Q
U
?
v
.
&
%
e
*
$
6
'
^
'

c
~
"
z
f
#
.
/
W
"
c
#
.
/
W
v
U
.
l
x
;
$
4
'
^
p
)

इसे ऑनलाइन आज़माएं!

Comments

क्या यह "सभी पंक्ति विराम सार्थक नहीं होना चाहिए" नियम को नहीं तोड़ता है?

— 12M2121

@ 12Me21 हाँ, मैं बस उसी को देख रहा हूं। तो पहले वाला हटाए जाने पर उसे तोड़ देता है, लेकिन कुछ अन्य को वास्तव में हटाया जा सकता है, इसे 2 की लंबाई के रूप में डालते हुए। धिक्कार है, मैंने एक दृष्टिकोण प्रति पंक्ति एक चर के साथ काम करने वाले युगों को बिताया!

— डोम हेस्टिंग्स

@ 12Me21 मुझे लगता है कि मुझे एक समाधान मिल गया है जो अब 2 के लिए काम करता है, मैंने 1 बाइट की लंबाई के एक गोल्फ संस्करण को जोड़ा है क्योंकि मैंने इसे बनाने के लिए समय बिताया है, नियम! :)

— डोम हेस्टिंग्स

Answer 11

SmileBASIC, 9 7 बाइट्स प्रति पंक्ति, 159 155 154 152 बाइट्स

यह वास्तव में मजेदार चुनौती थी। दुर्भाग्य से, अनावश्यक लाइन ब्रेक के खिलाफ नियम कुछ समस्याओं का कारण बनता है, (हालांकि सौभाग्य से यह यहां अधिकतम लाइन लंबाई को प्रभावित नहीं करता है।) मुझे लाइनों के बीच टिप्पणियों को जोड़ना था A%=I/3और A=A%*3, चूंकि A%=I/3A=A%*3SB में सही ढंग से पार्स किया गया है। मैं कुछ टिप्पणियों को छोड़ने के लिए एक ट्रिक का उपयोग करने में सक्षम था, क्योंकि उस लाइन को बदलने के 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

The biggest limitation here is getting input. INPUT x is the simplest way allowed, the alternative being to define a function with an input value like DEF F x but that is still 7 characters. Making a conditional statement is also hard; I can't think of anything shorter than WHILE x.

Comments

If A%=I/3A=A%*3 is syntactically valid but logically broken, you don't need the comment char.

— Nick T

It's correctly parsed as A%=I/3 and A=A%*3, so the comment is required.

— 12Me21

Answer 12

JavaScript (ES6), 3 bytes per line

Uses the global variable top to access the window object, from which we eval the following code:

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

You'll have to run it in the console as top is inaccessible from a sandboxed Stack Snippet.

---

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

Answer 13

C#, 9 bytes per line, 248 242 230 bytes

Since C# doesn't care about linebreaks, it needs a oneline comment at the end of almost (thanks Ørjan Johansen) every line to comply with the rules. This program expects n as a command line argument. Here's with as many non-deletable newlines as possible:

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

But since the longest line is 9 bytes, other lines can get that long too, shaving off some bytes:

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

Comments

I have interpreted the concatenation as being "with no space between", so you don't need // between tokens that would fuse together, like static and void.

— Ørjan Johansen

@ØrjanJohansen Thanks! Saved 6 bytes

— Arthur Rump

I think maybe you can save more bytes by rearranging into var s="";if// (i%3==0// )s+=// "Apple"// ;if(i%5//.

— Ørjan Johansen

And there's a similar opportunity to move A from the first to the second line.

— Ørjan Johansen

And also saved 3 bytes by changing "\n" to @"", with the second quote on a new line, making that newline required too.

— Arthur Rump

Answer 14

Python 2, 5 bytes/line, 93 bytes

The max6 standard is already obsolete.

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

Try it online!

Python 2 and 3, 5 bytes/line, 100 bytes

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

Try it online!

Answer 15

JavaScript, max of 6 bytes/line, 528 bytes

Idea ripped from here.

Code ripped from here.

Thanks to Anders Kaseorg for g=eval, saving a byte per line.

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'

Comments

a=""+\n"f"+\n"o"+ ... and ending with eval(\na) is slightly shorter

— Value Ink

The rules changed slightly (ApplePie, take an input), but your scheme should still be valid.

— Nick T

The rule change invalidates @ValueInk’s suggestion, but you could still end with f=eval and f(a).

— Anders Kaseorg

@AndersKaseorg thank you :) didn't think of that

— Stephen

You can save a byte by putting 2 characters in the string on the first line.

— 12Me21

Answer 16

PHP, 4 Bytes/line

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

Try it online!

Comments

All line breaks must be meaningful. Line breaks that can be removed and adjacent lines concatenated without an impact on the output, must be removed.

— Julian Wolf

@JulianWolf I have change it

— Jörg Hülsermann

Answer 17

APL (Dyalog), 5 bytes per line

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

Try it online!

Answer 18

रेटिना , 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.
$.&

इसे ऑनलाइन आज़माएं!

Answer 19

आर , 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 कोड है ( मिकी के गोल्फ से यहाँ अनुकूलित )।

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

और पार्सिंग कोड का अनगोल्डेड संस्करण:

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

यहाँ मैं toStringप्रतीकों की सूची को aएक स्ट्रिंग में बदलने के लिए उपयोग करता हूँ । हालाँकि, डिफ़ॉल्ट व्यवहार प्रत्येक प्रतीक को अलग करना है ,, इसलिए हम gsubउन्हें नल के साथ बदलने के लिए कहते हैं । फिर हम इसे पास करते हैं parseऔरeval to do the dirty work.

यह संभव है कि एक दृष्टिकोण है जो इस स्ट्रिंग पार्सिंग विधि का उपयोग नहीं करता है और बस सीधे fizzbuzz को लागू करता है, लेकिन यह मुझे लगता है कि वर्तमान दृष्टिकोण की तुलना में लंबी लाइनों का उपयोग करना forया whileउसकी functionआवश्यकताओं को परिभाषित करना है ।

Answer 20

रूबी, 10 5 बाइट्स / लाइन, 354 214 bytes

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

यह काम किस प्रकार करता है

रूबी स्वचालित रूप ?aसे एक ही बयान में स्ट्रिंग शाब्दिक (जैसे एकल-वर्ण शाब्दिक को छोड़कर) के अनुक्रमों को समाप्‍त कर देगा । इसका मतलब है कि x = "a" 'b' "c" %q{d}इसके बराबर है x = "abcd"। हम FizzBuzz जैसे कोड को कॉल evalकरने के लिए बहुत छोटे तारों में विभाजित करने के लिए इसका उपयोग करते हैं , क्योंकि +यह हटाने-नईलाइन्स नियम के कारण प्रोग्राम को अमान्य कर देगा, लेकिन नए अंक निकालने पर \सिंटैक्स त्रुटियों का कारण होगा!

Comments

मैं बस कुछ ऐसा ही प्रस्तुत करने वाला था

— dkudriavtsev

The rules changed slightly ('ApplePie, take an input), but your scheme should still be valid.

— Nick T

You can save a lot of bytes by adding two characters to the string on every line.

— NieDzejkob

@NieDzejkob the primary scoring mechanism here is bytes per line, meaning that it's better to sacrifice total bytecount to reduce line length.

— Value Ink

@NieDzejkob nvm मैं देख रहा हूं कि अब आपका क्या मतलब है, यह चूंकि शुरुआती evalलाइन बाकी की तुलना में लंबी है, है ना?

— वैल्यू इंक

Answer 21

जूलिया 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 बाइट्स अधिकतम के साथ किया जा सकता है:

जूलिया 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->- जूलिया को एक लाइन में इसे ठीक से पार्स करने के लिए एक लंबो की शुरुआत के रूप में आवश्यकता है।

Answer 22

पास्कल (एफपीसी) -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.

इसे ऑनलाइन आज़माएं!

प्रति पंक्ति 6 ​​बाइट प्राप्त करने के लिए एफपीसी का उपयोग करता है; इसके बिना, परिणाम बहुत बुरा होगा। यह या writeतो (या अनावश्यक व्हाट्सएप) होने के बाद से सबसे छोटी संभव रेखा चौड़ाई है , इसलिए इससे बचने के लिए एक विशेष टिप्पणी डाली गई है। FPC की विशेषताएं जिन्होंने इस उत्तर को प्रभावित किया है:;(

1. // - एक-पंक्ति टिप्पणियां शुरू करना।
2. प्रपत्र में ब्लॉक टिप्पणियाँ {$<something>...}संकलक के निर्देश हैं। यदि निर्देश मौजूद नहीं है, तो एफपीसी एक चेतावनी जारी करेगा (और {$ ...}साथ ही)। इस कार्यक्रम में, {और $एक नई पंक्ति के साथ अलग किया जाता है जो हटाए जाने पर चेतावनी जारी करेगा।
3. -Sew- संकलक भी हाल्ट चेतावनियों के बाद इतना है कि {और $शामिल हो गए रोकने के संकलन।

Answer 23

Japt , प्रति पंक्ति 3 बाइट्स

लगभग इसे दो बाइट्स प्रति पंक्ति तक ले जाने में कामयाब रहा, लेकिन अगर यह एक नई लाइन द्वारा पीछा किया जाता है, तो नक्शे से रिटर्न टूट जाता है।
FizzBuzz कार्यान्वयन स्वयं विहित FizzBuzz थ्रेड से है ।

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

इसे ऑनलाइन आज़माएं!

Answer 24

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 बाइट्स …, senrrr जोहान्सन के लिए धन्यवाद!

Comments

आप 8 से नीचे ... लाइन निरंतरता वर्ण के साथ प्राप्त कर सकते हैं। इसे ऑनलाइन आज़माएं!

— अर्जन जोहान्सन

मैं हर दिन इन esolangs के बारे में कुछ नया सीख रहा हूं। धन्यवाद, Oerjan!

— जोशइर्यान डब्ल्यूडब्ल्यू

Answer 25

पायथन 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\
)'

इसे ऑनलाइन आज़माएं!

Comments

सावधान! 'z\"'का मतलब वही है जो 'z\⏎ है "', इसलिए निरर्थक न्यूलाइन नियम का अर्थ है कि आपको स्ट्रिंग के अंदर एक निरंतरता रेखा शुरू करने की अनुमति नहीं है "।

— एंडर्स कासोर्ग

@AndersKaseorg ने इसे r'...'अब बनाया

— मार्टमिस्ट्स

यह फेंकता है a SyntaxError।

— निकोल निकोल

TIO एक नंबर को जल्दी बंद कर देता है। साथ ही, नियम का उपयोग FizzBuzzकरने से बदल गया है ApplePie।

— अर्जन जोहानसन

Answer 26

जावास्क्रिप्ट (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\
'\
`)
()

---

लंबी व्याख्या

जिस तरह से हम लाइनों को छोटा बना सकते हैं वह कोड को एक स्ट्रिंग में बदल रहा है और लाइन समाप्त होने से बच रहा है, इससे प्रति लाइन 2bytes की सीमा लागू होगी।

तो alert(1)बन जाता है

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

लेकिन अब आपका कोड एक स्ट्रिंग है इसलिए हमें स्ट्रिंग को कोड के रूप में निष्पादित करना होगा। मुझे पता है कि कम से कम 4 तरीके आप स्ट्रिंग को कोड के रूप में निष्पादित कर सकते हैं:

1. eval (कोड) । जिसे कॉल करने में कम से कम 5 बाइट्स लगते हैंeval(
2. सेटटाइमआउट (कोड, टाइमआउट) । रन असिंक्रोनस रूप से कार्य करता है, लेकिन वैकल्पिक रूप से यदि आप एक स्ट्रिंग पास करते हैं तो यह आंतरिक रूप से eval को आमंत्रित करेगा।
3. आप DOM का लाभ ले सकते हैं और अपना कोड a के अंदर डाल सकते हैं onclick="" विशेषता , लेकिन मैं तत्व निर्माण भाग को छोटा बनाने का प्रबंधन नहीं कर सका।
4. फंक्शन कंस्ट्रक्टर नए फंक्शन को इनवॉइस करना () आपके कोड को एक अनाम फ़ंक्शन में पार्स करेगा जिसे आप बाद में कॉल कर सकते हैं (मैंने इसका उपयोग किया था)।

अंदर सभी देशी कार्यों जीवन खिड़की वस्तु और जावास्क्रिप्ट में आप का उपयोग कर वस्तु गुण का उपयोग कर सकते डॉट नोटेशन तो 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)।

सभी मूल कार्य फंक्शन कंस्ट्रक्टर के उदाहरण हैं, और जावास्क्रिप्ट में सभी ऑब्जेक्ट्स में एक कंस्ट्रक्टर प्रॉपर्टी है। तो आप किसी भी मूल फ़ंक्शन पर फ़ंक्शन फ़ंस्ट्रक्टर का उपयोग कर सकते हैं alert.constructor, और कॉल विधि का उपयोग करके हम एक फ़ंक्शन के रूप में कंस्ट्रक्टर को निष्पादित कर सकते हैं। अब हमारे पास अलर्ट है। अवरोधक।कॉल (शून्य, कोड) एक फ़ंक्शन देता है।

पिछले thechiniques के संयोजन हम इसे में बदल सकते हैं alert['constructor']['call'](null, code)

अब हमें बस एक संक्षिप्त नाम या विधि खोजने की आवश्यकता है, इसलिए मैं स्ट्रिंग कंस्ट्रक्टर के अंदर बड़ी () विधि का चयन करता हूं । तो मैं इसे एक खाली स्ट्रिंग से सीधे एक्सेस कर सकता हूं"".big

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

फिर मैंने बस 2 बाइट्स में हर चीज को तोड़ दिया

शॉर्ट एर स्पष्टीकरण (TLDR)

मैं eval (कोड) के बजाय स्ट्रिंग को पार्स करने के लिए नए फ़ंक्शन (कोड) कंस्ट्रक्टर तक पहुंच रहा हूं । यह कंस्ट्रक्टर किसी भी फंक्शन को करके हर नेटिव फंक्शन पर उपलब्ध है। कंस्ट्रक्टर , जैसे । मैं String.prototype.big के अंदर एक फ़ंक्शन / विधि का उपयोग कर रहा हूं, लेकिन इसे सीधे स्ट्रिंग शाब्दिक से एक्सेस कर रहा है और इसे ब्रैकेट नोटेशन में बदल दिया है । का उपयोग कर इसे तोड़ने में सक्षम होने के लिए ।alert.constructor===Function String.prototype.big.constructor.call(null, /*string*/)"".big""['big']['constructor']['call'](0, CODE)\

Comments

दुर्भाग्य से, मुझे लगता है कि इस बीच किसी भी लाइन ब्रेक जैसे के बाद से अवैध है 'और ]हटाया जा सकता है और इस कार्यक्रम अभी भी सफलतापूर्वक चलेंगे।

— darrylyeo

मैं इसके बारे में किसी भी तरह से सोच भी नहीं सकता हूँ। इसकी चौड़ाई 2 है। लेकिन चूंकि हमारे पास लगभग समान दृष्टिकोण हैं , शायद आप अपने स्पष्टीकरण के अनुकूलित संस्करण को मेरे उत्तर में जोड़ सकते हैं, इसलिए सभी खो नहीं गया है?

— डेरीलीयो

Answer 27

पिप , प्रति पंक्ति 3 बाइट्स, कुल 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्हाट्सएप के बारे में पिप अत्यधिक लचीला है, इसलिए केवल एक रणनीति जो संभव लगती है वह है एक स्ट्रिंग बनाना, इसे इस तरह से संशोधित करना जिससे न्यूलाइन्स को परेशान न होना पड़े और इसे बाहर निकालना पड़े।

हम एक स्ट्रिंग बनाते हैं जहां हर दूसरा चरित्र एक नई रेखा है, और इसके हर दूसरे चरित्र का उपयोग UW(अनसुना) और एकात्मकता करें@ (पहले तत्व प्राप्त करें) लें:

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

का परिणाम @UWहमारे ApplePie कोड होना चाहिए, FizzBuzz समाधान से अनुकूलित यहाँ है । यदि स्ट्रिंग की कोई भी नई सूची हटा दी जाती है, तो यह सिंटैक्स त्रुटि या गलत आउटपुट देते हुए, पूर्ण कोड में परिणाम नहीं देगा।

स्ट्रिंग के बाहर अभी भी दो नए समाचार हैं। हमने Y(यैंक) संचालक के उपयोग से इसे अनिवार्य कर दिया है - जो यहाँ एक नो-ऑप के रूप में कार्य करता है - जिस तरह से पिप अपरकेस अक्षरों के रन को पार करता है:

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

इसलिए यदि ये नई कथायें हटा दी जाती हैं, तो कार्यक्रम अलग तरीके से चलता है और वह नहीं करता है जो इसे माना जाता है।

Answer 28

जावा 8, 7 बाइट्स प्रति पंक्ति, 171 बाइट्स

एक शून्य लैंबडा ले रहा है int। मुझे संदेह है कि यह नई कहानियों के संबंध में आवश्यकता का पालन करता है, लेकिन मैं इसे साबित नहीं कर सकता, और इसे क्रूर बल द्वारा सत्यापित करने में मेरे कंप्यूटर पर लगभग एक महीने का समय लगेगा। तो यह जाता है।

a->{//
System
s=//
null;//
for(int
i=0;i//
<a;)s//
.out.//
print//
((++i//
%3*(i//
%5)<1//
?(i%3//
<1?//
"App"//
+"le"//
:"")+//
(i%5<//
1?//
"Pie"//
:"")://
i)+//
"\n");}

यह ऑनलाइन की कोशिश करो

लाइन टिप्पणियों के कारण बहुत उबाऊ। यहाँ केवल दिलचस्प बात एक अशक्त Systemसंदर्भ का उपयोग है , जो कि प्रत्येक लाइन के नीचे 8 बाइट्स में मानक प्रिंट करने के लिए आवश्यक प्रतीत होता है। ध्यान दें कि printविधि कॉल अड़चन है।

कोई टिप्पणी नहीं के साथ Ungolfed:

a -> {
    System s = null;
    for (int i = 0; i < a; )
        s.out.print(
            (++i % 3 * (i % 5) < 1 ?
                (i % 3 < 1 ? "App"+"le" : "")
                    + (i % 5 < 1 ? "Pie" : "")
                : i
            ) + "\n"
        );
}