नए साल के लिए पुनर्चक्रण

23

2015 के लिए एक अच्छा संकल्प अधिक निरंतर रूप से जीना है। हम रीसाइक्लिंग करके शुरू करेंगे। रीसाइक्लिंग कोड, वह है!

आपका काम 2015नई पंक्ति (और केवल उस) को पीछे छोड़ते हुए नंबर को STDOUT में प्रिंट करना है । हालाँकि, आपको पीपीसीजी से कुछ पुराने कोड को रिसाइकिल करके ऐसा करना होगा। यहाँ है कि कैसे काम करता है:

  • CodeGolf.SE पर 2014-12-16 00: 00: 00Z (जिस दिन मैंने इसे सैंडबॉक्स में पोस्ट किया था) से पहले पोस्ट किया गया कोई भी उत्तर चुनें । अपवाद: आप पिछले साल के नए साल की चुनौती से किसी भी उत्तर का उपयोग नहीं कर सकते हैं ।
  • उस उत्तर में से एक कोड ब्लॉक चुनें (इनलाइन कोड स्निपेट नहीं, उसे अपने पैराग्राफ पर होना चाहिए)। इस ब्लॉक को वास्तविक कोड के रूप में विज्ञापित किया जाना चाहिए, जैसे आप परीक्षण मामलों या उदाहरण आउटपुट का उपयोग नहीं कर सकते हैं जो मोनोस्पेस प्रारूपण का उपयोग करने के लिए होता है।
  • इस चुनौती के लिए अपना सबमिशन बनाने के लिए उस कोड ब्लॉक के अक्षरों को फिर से व्यवस्थित करें । आप केवल आदेश बदल सकते हैं, किसी वर्ण को जोड़ या हटा नहीं सकते। इसमें नई कहानियां शामिल हैं।
  • आपको यह दिखाना होगा कि मूल स्रोत ब्लॉक आपकी भाषा में वाक्यात्मक रूप से मान्य है। सबसे अच्छे मामले में आप यह दिखा कर कर सकते हैं कि यह संकलन-समय या रन-टाइम त्रुटियों के बिना चलता है। इसलिए जब मूल कोड जावा हो सकता है, तो आप इसे व्हॉट्सएप उत्तर के लिए उपयोग कर सकते हैं (जैसा कि हर फाइल व्हॉट्सएप में मान्य है), लेकिन संभवतः इसका उपयोग पायथन जवाब के लिए नहीं किया जा सकता है (क्योंकि मूल मान्य पायथन सिंटैक्स नहीं होगा। )।

ध्यान दें कि आपके उत्तर को सभी इनपुट और बाहरी स्थिति (वास्तविक वर्तमान तिथि सहित) को अनदेखा करना चाहिए। यह STDIN से पढ़ सकता है , कहते हैं, जब तक कि यह खाली नहीं है, दुर्घटनाग्रस्त नहीं होता है, और स्ट्रीम के सभी संभावित सामग्रियों के लिए समान आउटपुट का उत्पादन करता है।

आपके परिणामी कोड को एक पूर्ण कार्यक्रम होना चाहिए (न कि एक फ़ंक्शन, और न ही एक स्निपेट जो एक REPL वातावरण मानता है)।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर ( बाइट्स में) ) जीतता है।

लीडरबोर्ड

मुझे यकीन है कि यह विभिन्न भाषाओं में बहुत अलग तरीके से खेलेंगे। तो निम्नलिखित स्टैक स्निपेट एक नियमित लीडरबोर्ड और भाषा द्वारा विजेताओं के अवलोकन दोनों को उत्पन्न करता है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

कोड स्निपेट दिखाएं

code-golf  number  restricted-source  new-years 
— मार्टिन एंडर
स्रोत
प्रत्येक व्हाट्सएप कार्यक्रम मान्य नहीं है; मुझे ideone.com/Jphkf3 के
— Ypnypn
यह सवाल मेरे दिमाग में आया: क्या मूल कोड को इस तरह से रीसायकल करने की अनुमति है कि आप मूल के एक बड़े हिस्से को कमेंट करें?
— प्रोग्राम फॉक्स
@ProgramFOX हाँ, क्योंकि अगर आपको बहुत सारी टिप्पणी करनी है जो शायद आपके स्कोर को नुकसान पहुंचाएगी।
— मार्टिन एंडर
@Ypnypn यह मेरे लिए एक रनटाइम त्रुटि जैसा दिखता है, सिंटैक्स त्रुटि नहीं, सही?
— मार्टिन एंडर

जवाबों:

22

गोल्फस्क्रिप्ट, 9 बाइट्स

मूल जवाब (झलक!) है जो मैं कैसे पता है कि यह वाक्य रचना मान्य है GolfScript में भी है,। मैंने http://golfscript.apphb.com/ पर परीक्षण किया ।

2015}{.**

मैं गोल्फिंग के लिए डिज़ाइन की गई भाषाओं के उपयोग से घृणा करता हूं, लेकिन मुझे यह चुनौती जीतनी थी, इसलिए मैंने इस उत्तर को पोस्ट करके अपने मूल्यों को धोखा दिया। मुझे नहीं पता कि इस भाषा में अधिकांश पात्र क्या करते हैं, लेकिन मैंने एक बार अनजाने में सीख लिया, जबकि एक गोल्फस्क्रिप्ट उत्तर को छोड़ते हुए, कि एक बेजोड़ }टिप्पणी बाकी कार्यक्रम से बाहर हो गई। इससे मुझे बाकी किरदारों को नजरअंदाज करना पड़ा।

— feersum
स्रोत
1
हुह, मैंने कभी नहीं सोचा था कि बेजोड़ ब्रेसिज़ जीएस में मान्य होंगे।
— मार्टिन एंडर
3
@ MartinBüttner क्या आपने यह
— FryAmTheEggman
16

बेफुंज -93, 2085 बाइट्स

मैंने सोचा था कि मैं पुनर्नवीनीकरण करूँगा और सबसे अच्छा पुनर्नवीनीकरण करके मेटा जाऊंगा । यहाँ संक्षिप्तता के लिए किसी भी पुरस्कार के लिए नहीं जा रहे हैं।

+2012+1+1e1 or b+bbv+b+NN
"a"""""
p((('?'.ord-' '.ord )/(1.0/'A'.ord)).to_i)
<<id
                   1
                   !
                   _"  fabaaaca"-.-.-.-.+"O"2::++p

aa
AaAAaAAaAAaAAaA
eEe ddd OoOOoOOoOOoOOoOOoOOoOOoOOoOOoO ddD Ccc eEE
ccc LLl
SssSss LLl
SsS LLl
SsSSsSSsSSsS LLl
cccccc
mMm



+   +     a     pppp  pppp  y   y     n   n eeeee +     +    y   y eeeee     a     rrr    "
+   +    a a    p   p p   p  y y      nn  n e      + + +      y y  e        a a    r  r   "
+++++   aaaaa   pppp  pppp    y       n n n eee    + + +       y   eee     aaaaa   rrr    "
+   +  a     a  p     p       y       n  nn e       + +        y   e      a     a  r  r
+   + a       a p     p       y       n   n eeeee   + +        y   eeeee a       a r  r   "



Hope to see another round of awesome programming puzzles and code golf challenges

===============================
"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' ' ' ' '

Big char dump below (will clean up if there's more languages to squeeze in):

  $$$$$$$()++++++++++++++++++++++++++++--------------------------/////:::;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<>>>>>??AAACCDDEEEFHHLLMMMMM
NOOOOOOOOOOORRRRRRRRRSSSUUUUV[\]___aaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbcccccccccccccddddddddddddddddddddddddddddddddddddddd
ddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeee
eeeeeeeeeeeeeeeeeeffffffffffghhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiilll
llllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnn
nnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppp
ppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssss
ssssssssssssssssssssssssstttttttttttttttttttttttttttttttttttttttttttttttttt
ttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
uuuuuuuuuuuuvvvvvvvvwwxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy
yyyyyyyyyyzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

"""
one=1
print(int(ord('A')/(one/(ord(' ')-one))))
id
"mOO"

यह वास्तव में 5 भाषाओं के लिए एक बहुभाषाविद भी है: Befunge-93 , ooo Code , Pyth , Python 3 और Ruby। हालाँकि, चूंकि मूल कोड Befunge-93 के लिए केवल वाक्यात्मक रूप से मान्य है, मैं केवल वही गिन रहा हूं।

दुर्भाग्य से मूल कोड में केवल एक जोड़ी थी []और बहुत सारे .एस, इसलिए मैं वास्तव में ब्रेनफक को फिट करने में सक्षम नहीं था (इसलिए ऊ कोड)।

टिप्पणियाँ

यह आश्चर्यजनक रूप से प्रतिबंधात्मक निकला, क्योंकि:

  • उपलब्ध अंकों का पूरा सेट रूबी और पायथन 001111111222के उपयोग की आवश्यकता है ord। विशेष रूप से वहाँ कोई नहीं है 5, जो पायथ के लिए एक दर्द बन गया।
  • कमी का @मतलब है कि Befunge के pलिए जगह की जरूरत है @।
  • कमी का *मतलब है कि हमें एक संख्या के व्युत्क्रम से विभाजित करके गुणा करना था। मज़ा।

Befunge-93

Befunge प्रोग्राम है

                   v
                   1
                   !
                   _"  fabaaaca"-.-.-.-.+"O"2::++p

जहां हमने बेकार निर्देशों को छोड़ दिया है। हम प्रत्येक अंक को विशेष रूप से cabfबनाम वर्णक्रम के बीच ASCII मूल्यों में अंतर के रूप में अंकित करते हैं a।

ऊ कोड

इसी BF है

>><->>->>>><>+++++[>++++++++++<-]>.--.+.++++.>>[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>->>>>>>>>>>>>>>>>>>>>>>->>>>>>>>>>>>>>>>>><;;;;;;;;;;;;;;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>->>>]

जिनमें से एकमात्र प्रासंगिक हिस्सा है

+++++[>++++++++++<-]>.--.+.++++.

Pyth

पायथ केवल पहली पंक्ति को निष्पादित करता है, इसलिए

+2012+1+1e1 or b+bbv+b+NN

ध्यान दें कि पायथ एक उपसर्ग संकेतन का उपयोग करता है, इसलिए लाइन का पहला भाग वास्तव में है

2012 + (1 + (1 + (1 % 10)))

( नोट: eसाधन%10 )

पायथ की प्रकृति के कारण, यह स्वचालित रूप से मुद्रित होता है। शेष पंक्ति वैध पाइथ है, लेकिन oस्वचालित प्रिंटिंग को दबाने से पहले की पूर्ववर्ती जगह ।

अजगर ३

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

+2012+1+1e1 or b+bbv+b+NN
"""
...
"""
one=1
print(int(ord('A')/(one/(ord(' ')-one))))
id

पहली और आखिरी पंक्तियाँ वाक्यविन्यास रूप से मान्य हैं, लेकिन कुछ भी नहीं। बीच की दो लाइनें प्रिंट करती हैं जो हमें चाहिए।

माणिक

रूबी कोड समान है, लेकिन हम प्रोग्राम के अधिकांश बाहर टिप्पणी करने के लिए ट्रिपल उद्धृत स्ट्रिंग के बजाय एक हेरेडोक का उपयोग कर रहे हैं। कुछ आवारा तत्वों को अनदेखा करना, हमारे पास है:

+2012+1+1e1 or b+bbv+b+NN
p((('?'.ord-' '.ord )/(1.0/'A'.ord)).to_i)
<<id
...
id

एक बार फिर, पहली पंक्ति वाक्यात्मक रूप से मान्य है, लेकिन कुछ भी नहीं करता है। दूसरी पंक्ति प्रिंट करती है कि हमें क्या चाहिए।

— Sp3000
स्रोत
4
हे, आपको निश्चित रूप से "सबसे छोटा कोड" पुरस्कार नहीं मिला है, लेकिन रचनात्मकता के लिए +1!
— दरवाज़े
11

CJam, 12 बाइट्स

T~mp[]!_1+oE^

खोलना कोड विषय यादृच्छिक संख्या मुद्रण के लिए एक बहुत अच्छा स्रोत है। यह एक साथ टुकड़ा करने के लिए काफी मजेदार था :)

T~     bitwise not of 0 is -1                     [-1]
mp     replace with 0 as -1 is not prime          [0]
[]!    not of an empty array (falsy) is 1         [0, 1]
_      copy that 1                                [0, 1, 1]
1+     add 1                                      [0, 1, 2]
o      output top of stack                        [0, 1]           2
E      push 14                                    [0, 1, 14]       2
^      bitwise xor                                [0, 15]          2
       (CJam implicitly prints stack afterwards)  []               2015

बोनस जवाब

14 बाइट्स:

36.e8 .79e2%15

19 बाइट्स:

0_*1_)@@{_%\_)*\};5
— Sp3000
स्रोत
7

शुतुरमुर्ग, 198

मैं एक शुतुरमुर्ग का जवाब पाने के लिए उत्साहित हूं; मुझे परवाह नहीं है कि यह कितना लंबा है। : P (यह संस्करण 0.5.0 है , वैसे)

{: rotate ( circ n -- )
    neg swap change-circular-start

IN: 1 9 [a,b] <circular> dup 6 rotate >array .
{ 4 5 6 7 8 9 1 2 3 }
IN: 1 9 [a,b] <circular> dup 3 rotate >array .
 7 8 9   3 4  6 };2 n15

मूल :

: rotate ( circ n -- )
    neg swap change-circular-start ;

IN: 1 9 [a,b] <circular> dup 6 rotate >array .
{ 4 5 6 7 8 9 1 2 3 }
IN: 1 9 [a,b] <circular> dup 3 rotate >array .
{ 7 8 9 1 2 3 4 5 6 }

मेरे द्वारा परिवर्तित सभी निम्नलिखित थे:

  • 2 n15एक ब्लॉक ( {}) के अलावा सब कुछ लपेटा जाता है जो तुरंत पॉप होता है ( ;)।

  • 2 n15अंत में अटक गया। 2एक धक्का 2, एक nधक्का 0, और 15धक्का 15, जो अंततः 2015आउटपुट बन जाता है ।

यह वास्तव में मुझे एक बग खोजने में मदद 2n15करता है : किसी कारण से काम नहीं करता है (यह प्रिंट करता है215 ), लेकिन दोनों 2 n15और 2n 15काम करते हैं। मुझे पता लगाना होगा कि क्यों है ...।

यह खोज क्वेरी मैंने इस सही कोड नमूने को खोजने के लिए उपयोग की है:

बनाया गया: .. 2014-12-16 है: उत्तर कोड: "2" कोड: "0" कोड: "1" कोड: "5" कोड: "]" कोड: ";"

यह जवाब 140 के लिए काम करेगा, लेकिन मैं यह देखने जा रहा हूं कि क्या मैं छोटा हो सकता हूं ...।

— Doorknob
स्रोत
7

जावास्क्रिप्ट, 26 बाइट्स

मूल :

alert(998|(103>8>0&41>-0))

पुनर्नवीनीकरण:

alert(4030>>(998>1|8&1-0))

यह सिर्फ दाईं ओर 4030 एक बिट में बदलता है।

— gRC
स्रोत
5

CJam, 14 बाइट्स

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

मूल उत्तर:

92e8.17 5e6.3%

पुनर्नवीनीकरण 2015:

9.68e3 .7e2%15

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

9.68e3 is 9680
.7e2 is 70
9680 70% is 9680%70 = 20
15 is 15

तो स्टैक में शामिल है 20और 15जो एक के बाद एक मुद्रित होते हैं, 2015 की छपाई

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
5

मारबेलस, 54 बाइट्स

बोरिंग जवाब (54 बाइट्स)

32303135
:R
:Q
++003333333567QQRR}0

(इसके बाद 54 बाइट्स के बराबर नई अनुगामी का एक टन)

मूल उत्तर

मुख्य बोर्ड बस के प्रत्येक चरित्र का प्रतिनिधित्व करने वाले मार्बल को गिराता है 2015। RतथाQ बोर्ड परिभाषित होते हैं, लेकिन कभी उपयोग नहीं किए जाते हैं।

वैकल्पिक उत्तर (92 बाइट्स)

3W!!?0]]>W/\&0&1@1@0@0
      ]]>W/\&0&1@1@0@0
                @1  @0
03  02
\\  //
32+A
  Dp

मूल उत्तर

रिक्त कोशिकाओं के रूप में रिक्त स्थान की जाँच की जानी चाहिए। यह पहला प्रिंट 2(0x32), फिर 0x03+0x02+0x0A=0x0F=15तीन अंकों के दशमलव ( 015) के रूप में प्रिंट करता है । पहली तीन पंक्तियाँ कुछ नहीं करती हैं।

यहाँ उत्तर का परीक्षण करें।

— es1024
स्रोत
4

अजगर, २५

https://github.com/isaacg1/pyth

J6ifqT++2010/JJ4U*2^TJ^TT

यहाँ मूल उत्तर (pyth में भी लिखा गया है) है। मुझे पता है कि यह एक बहुत ही प्रतिस्पर्धी उत्तर नहीं है (लंबाई 26 का अजगर उत्तर है), लेकिन मुझे वास्तव में इसके साथ आने में बहुत मज़ा आया, और मुझे लगता है कि यह एक विनम्र जवाब है।

स्पष्टीकरण:

J6                           : J=6
  i                   ^TT    : convert_to_base(..., 10 BILLION)
   fqT          U*2^TJ       : filter(lambda T: T==..., range(2*10^6)
      ++2010/JJ4             : 2010 + J/J + 4

मूल रूप से यह 2015 के बराबर होने के लिए पहले दो मिलियन नंबरों की सूची को फ़िल्टर कर रहा है। फिर, यह संख्याओं की सूची को आधार 10 बिलियन नंबर के अंकों के रूप में मानता है। शुक्र है, रेंज में 2015 के बराबर केवल एक संख्या है, इसलिए आपको 2015 * 10000000000 ^ 0 मिलता है, जो कि सिर्फ 2015 है। इसे चलाने में कुछ सेकंड लगते हैं।

— FryAmTheEggman
स्रोत
2

गणितज्ञ, 60 बाइट्स

⌊DF@IM~RS~ad~ee~ee~ggggiiimmnnoorrrstt~.22346⌋Print@2015

स्रोत

Floorब्रैकेट में हिस्सा गैर-मौजूदा कार्यों के फ़ंक्शन अनुप्रयोगों की एक श्रृंखला है (जो कि गणितीय प्रतीक के साथ समस्या नहीं है, क्योंकि इसके प्रतीकात्मक गणना मॉडल के कारण)। इसी तरह, बस फर्श लिख रहा है और Print@2015गुणा है, जो गणितज्ञ भी शिकायत नहीं करता है। सिंटैक्टिक शुगर के बिना, यह होगा

Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]] * Print[2015]

चूंकि हम आरईपीएल वातावरण नहीं मान रहे हैं, इस का मूल्यांकन परिणाम कभी नहीं छपा है (जो होगा Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]] ), लेकिन केवल साइड इफेक्टPrint वास्तव में STDOUT को जाता है।

इस स्रोत को चालू करने के लिए Sp3000 का धन्यवाद।

— मार्टिन एंडर
स्रोत
2

> <>, 57 बाइट्स

मूल C ++ कोड, RadioASCII चुनौती से :

#include <cstdio>
int main(){int x;printf("Lawrencium");}

पुनर्नवीनीकरण > <> (मछली) कोड:

eclne)nfn;
   ""#(();<>Laaccddiiiiiiimmnnnoprrsttttuuwx{}

Befunge की तरह,> <> स्टैक-आधारित 2D भाषा है। निष्पादन शीर्ष बाएं से शुरू होता है और शुरू में दाहिनी ओर होता है। कार्यक्रम की केवल पहली पंक्ति को निम्न तरीके से निष्पादित किया जाता है:

e      Push 14                          [14]
c      Push 12                          [14, 12]
l      Push the length of the stack     [14, 12, 2]
n      Output as num                    [14, 12]          2
e      Push 14                          [14, 12, 14]      2
)      Push 1 if greater than else 0    [14, 0]           2
n      Output as num                    [14]              20
f      Push 15                          [14, 15]          20
n      Output as num                    [14]              2015
;      Terminate                        [14]              2015

अब बड़ा सवाल है - C ++ कोड मान्य> <> क्यों है? में> <> कार्यक्रम प्रवाह की दिशा बदलने के तरीके हैं (यह एक 2D भाषा है, सब के बाद):

^>v<     Arrows which direct program flow a certain direction
_/|\     Mirrors which reflect the direction of program flow
#        Four-way mirror, reflect from all directions

जब C ++ कोड निष्पादित किया जाता है, तो प्रारंभिक #प्रतिबिंबित प्रोग्राम प्रवाह बाईं ओर होता है। लेकिन> <> टॉरॉयडल है, इसलिए निर्देश सूचक चारों ओर लपेटता है, लाइन के अंत से दिखाई >देता है , जो सीधे प्रोग्राम प्रवाह को सही दिशा में पूरा करता है। पॉइंटर फिर से लपेटता है #, वापस बाउंस होता है >... और इस तरह एक अनंत लूप होता है और एक त्रुटि कभी नहीं होती है।

— Sp3000
स्रोत
1

पायथन 3, 1878 बाइट्स

बहुत लंबा, लेकिन वैसे भी साझा करना चाहता था:

import sys,re,zlib as z,base64
print(2015)#,PIL.Image as ire.search(str(z.adler3(i.open(sys.argv[1]).tobytes()[2::6])%203)+'(\\D+',z.decompress(base64.b8decode(b'c${Tc%XZ>86NyfdNqBH<%b?iLI_EpFkwO-GfQC$tcfjoB$+h*^;0s?o$g*?uzgjxs%~BKif!C3zALZEU!&?wJd#-mqgS@p<P&+)AsV|c*52*C>U&(_4w^urvvWJU8Bj;bvv4ia;eiJLu+bsXLru`DjH|W<`|;xLq++kv5k8VWZgQe*`_u+opEF8>A6qjM%k#skzbiuJ7dL_*><K@9l6!M*H(|w)PZJ2`RYy7K2VVrv+zc)&2Fc?wvh|^#ksyymE?D!Q$3!LbFX%h%vT%1#lr486Iybw?0!`H)ZlZ#XIao2uXTr}(IBl@wRWHa#})bgV);O3HoW7+T*!5M3=^mu6Ri$`7L;uUWj~gsqR6gQR9h7^nKdBIgy>ats36%|M|8p1x;32(ZfK9R5_xK5ts=Sz70c%SIK&g3N1E|sg{n3>JSbKwwhssGcb$8uMNw=Nv;f_;rj?}kz(3-&#FQw@O;q(8nGHjbrTC(NQv=ckXT|eHr|amahCq(7T6<LBTr5Gj>fHV~3DcYINN!Qr`6Dl?jT>!4u5~bb%Zi6VTax;%vg*m325J_$nEC%yqbbYeEp!K_K7k)W-XCP`6+}N7tktMVX+{@c2L&kLAc&IvspGrzZ$F`uOBg}fA3W2neAU}tg~<+iCN=<sR^Zke+9WNhnCyy6!8nfa>33&OWiPt2s=OMTrUgilSYQxrG!gziB!Aj83zX&6S|yjIQkA?iF0n%?<+B=%_D11aoCv?@Q&eei{sqNkr7RG`#*xyzSUE6BUNnZK)3|3Wls}K$qaKv;jOO#!{3Ms)4CQ?shafnAF^zVq(`K9o2xL5JoQoGea+W1$+xmw&8OMOtN1Pid6UAcd+*_bB6IY$KjrO=ac^tPv3(8O`&(agOBbT{Va6s}Rm9&`I#yivC;MhW8=n+^^&Reho;~!~W<xgH6bVq3^=H7)sUXV2nv~DP4`CY`f55i&qH)DvPMQy>)y*Z=|68w@v=#oo5^RSh5R2F%1-vt>h=|+1n0pE^Yq-72!)1+o{hD_3<Cyxpyr6r%cei-AFQ*h1seM$MP>ovLS2k#Ci$to#do$s3MXu2lZsw~9HkbjVWM@1!{w>}LWVj#j2qC(+*Okc>=<qcV}*}+U_QK+(ZZ(x>ZMdDDWtgHiBK+7p6aHHI`u-h6z7|Xm`>D1t4uEp271y7oCI^{1^H~O7QRxTA_U&92Q8z$J2O|5Lbeg_0umd^pSU<%-ki7LtDvo&AgIt0h~6(y@Hr+kyLJ$<B#07KdGob0EW$7@f{GszaUv#tkpSyk759Khmvq-aiyM-_&x_VCTx$Vy<;$<k{T$-@{Mhc<<%KD1AHK^MKkg%pYIW}SxhV?&a{o9=rs@*+hqyoioE=TF>9S<KxY+^69^OA0jkS#0!w@kw4}KTcP9#+PVW+qB|7B`Y?eRs+7}8RSAs?i?-Cz#Wp(Iihd`nI!Q_i%R^o_;fvDQ5|{Cr;yWeirL>_l#(wn)$QenJkK6Sgw)5NleBzvo&G#@>X`7Ib*aS4LHx9epI%BXXV&y7LJ&54g}D25-Q8>DZQ5hGKyIeJkQQu08%j|<x~)q(AOVw9P~Z*c0Z@VM6n#<}tBT6+T%4mZ9f*y76xlEFM~o$xr9*SZHd^6D-C!pkkp3m(-~W3&>KY@106L+;I><MJ^Dz`f{(I3i?u`2pWjUjlwZx`B1JB#h#u3xTH*b1K?TG40|4lxF1$_Pw+t?h2')).decode()).group(1))

केनीटीएम के जवाब से लिया गया ।

मैंने देखा कि कोड में 2, 0, 1 और 5 और # पाया जा सकता है, इसलिए मैंने कुछ चार्ट बनाने के लिए स्थानांतरित किया print(2015)और बाकी की टिप्पणी कर सकता था। मैंने पीआईएल आयात को भी टिप्पणी में डाल दिया है इसलिए इसे उस पुस्तकालय की आवश्यकता नहीं है।

— ProgramFOX
स्रोत
1

PHP, 21 बाइट्स

<?=65*4*31*2/8;//7**9

चलो फिर से यह कोशिश करते हैं। स्रोत कोड खोलना से दूसरे PHP उत्तर से लिया गया । यह बहुत बुनियादी है, लेकिन अब तक यह गैर-गोल्फ भाषा में सबसे छोटा कार्यक्रम है। आप इसे http://codepad.org/15EjIYAU पर सत्यापित कर सकते हैं । मूल कोड इस प्रकार है:

<?=9*8*7*6*5*4/3/2/1;
— NinjaBearMonkey
स्रोत
तुम भी जरूरत नहीं है 4*2/8;)
— मार्टिन एंडर
मुझे पता है, लेकिन मैं इसे और अधिक दिलचस्प बनाना चाहता था, और इसे किसी भी तरह से टिप्पणी की जाएगी।
— NinjaBearMonkey
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.